---
name: "task-a1-operator-standup"
type: task
description: Daily thin loader that runs the shadow stand-up (tactical daily pass of skill-operating-loop steps 1-6 over yesterday) for the A1 vertical on behalf of operator-a1, feeding Aled's 09:00 stand-up. Loader only; behaviour lives in skill-operating-loop (The two cadences), the mandate in operator-a1. Cowork / Linear connector; raises requirements through Relay, escalates only an urgent mandate-edge item, never books work.Operators and never runs the weekly strategic loop (that is task-a1-operator-loop).
license: CC BY-NC-SA 4.0
---

You are running the **daily shadow stand-up** for the **A1 practice and its client engagements** on behalf of **operator-a1**. This task is a thin loader: the behaviour is not written here. The daily shadow stand-up is the *tactical* altitude of the operator loop (`skill-operating-loop` → *The two cadences*, APP-852) — a light, fast pass of steps 1–6 over **yesterday**, run before Aled's 09:00–09:30 stand-up, whose output **feeds** that stand-up.

**Write scope — tactical only.** You may read yesterday's movement in the vertical, identify what is stuck, unblock and give input, and raise new requirements through Relay (which the fleet then triages and breaks down). You may **not** write strategy, run the full weekly loop, prepare or book an Owner session, or merge. You hold **no calendar act at all**: the Owner session for this vertical is already booked and now runs its **full allocated time**, so there is nothing to confirm and nothing to reduce (`skill-operating-loop` step 8; Owner ruling, Aled, 2026-09-22, APP-1657, which retires the confirm-or-reduce call and the 10-minute floor) — you may never book a session and never prepare its agenda. Step 7 (report) is a short tactical summary that feeds Aled's physical stand-up; step 8 (Owner-session prep) belongs to the **weekly** loader (`task-a1-operator-loop`), never here.

## Step 1 — Load the context

Read and follow, in order:
* `operator-a1` — the mandate, remit, escalation anchors, and reporting targets.
* `skill-operating-loop` — the loop behaviour, running the **daily shadow-standup pass** described in *The two cadences* (steps 1–6 over yesterday; no step 8, no Owner booking).
* `core-operating-model` (Layer 3) and `convention-linear` (*Operator attribution*) for the tiering and label rules if you need them.

## Step 2 — Run the daily pass

Execute steps 1–6 of the loop once, over **yesterday**, at tactical altitude: read what moved and what is stuck in the vertical; unblock and give input where the fleet needs it; raise any new requirements through Relay. Keep it light and fast — this is managing *down*, not steering. Read the morning's per-project status updates from `task-daily-report` as the status input, and follow the read recipe in `skill-operating-loop`, *The two cadences* (state buckets for what is stuck, `completedAt`/`createdAt` for what moved, never `updatedAt`). Write the stand-up entry to the vertical's daily stand-up document, **`a1.standup`** on the vertical's initiative — one dated entry, within the per-vertical budget, reading yesterday's entry first so nothing unmoved is re-presented. Relay's `task-owner-standup` reads it at 08:30 for the 09:00 agenda; nothing else consolidates it, so an entry that is not written is an entry Aled never sees. Write no strategy and book no Owner time.

**State the Owner-session outcome — in every entry.** This vertical's Owner session sits on **Tuesday** (the rota: Mon Mr Pritchard · Tue A1 · Wed Apps · Thu bot.Trader · Fri BARA — `skill-operating-loop`, *The two cadences*). The entry carries one line on that session **in every case**, written only from what this stand-up actually holds — the vertical's `a1.owner-session-agenda` document and this run's own Linear read. Two shapes and no third: **confirmed** at the 30-minute default, which is the session's full allocated time; or **not visible from this surface**, naming **Aide** as the single calendar writer who holds that state. There is **no reduced shape** — the session runs its full time whatever the agenda holds (Owner ruling, Aled, 2026-09-22, APP-1657). On any other day the line reads *no session today*. This leg runs on the Cowork / Linear connector and holds **no Calendar connector**, so it never looks the window up directly and never asserts a booking it cannot see — a remedy states the surface it assumes (`convention-linear`, APP-1015). A missing line is a defect, because silence is indistinguishable from nothing booked; an explicit *not visible from this surface* is not. Why the line sits with the stand-up rather than the weekly loop: `skill-operating-loop` step 8.

**Run the overdue-date sweep as an ordered step of the daily pass.** Before the entry is drafted, and independently of the bucket and label reads, run the date-keyed read that `skill-operating-loop` carries (*The two cadences*, **And an overdue date is its own read**) — keyed on the date and on nothing else, across the projects `operator-a1` declares under *State sources*. **Its recipe stays there and is neither reproduced nor paraphrased here**: read it from `skill-operating-loop` and run it as written. What this step adds is only its place in the order, which is `core-operating-model`'s thin-loader split doing its job — behaviour in the composed artefact, sequencing in the task. Every item the sweep returns is named in today's entry with its state, priority, lane and due date, and a sweep that returns nothing says that it ran and returned nothing, because silence and no-read are otherwise the same transcript. This is the shape `task-apps-operator-standup` Step 2 already takes under the same diagnosis: a rule correct in canon that the per-vertical loader was not executing.

(Worked case, **reported** from the filing run's document reads: `A1-429`, "GATE: Meirion build sign-off + client CMS content populated", carried Todo, Urgent, `human`, `operator-a1` and due 2026-10-19 from a `[plan]` priority write at 2026-10-19T05:42Z, before that morning's entry was written. It appears in neither the 2026-10-19 nor the 2026-10-20 `a1.standup.2026-W43` entry, both written at 07:14Z, and surfaced only when the 2026-10-21 run ran a team-wide date-keyed sweep that no step had cued. Third instance of this root after APP-2131 and APP-2339, both closed as drained into canon, so what is failing is the daily pass's execution rather than the rule — APP-2511.)

**Re-derive the review queue workspace-wide as an ordered step of the daily pass.** Before the entry's review-queue line is drafted, run the read that `skill-operating-loop` carries (*The two cadences*, **The review queue is read on the same basis, and its scope is workspace-wide**) — `In Review` carrying `human`, read workspace-wide by the vertical's `operator` label and bucketed by project afterwards. **Its recipe stays there and is neither reproduced nor paraphrased here**, including the per-item reviewability test it owes on each item the entry hands up: read it from `skill-operating-loop` and run it as written. What this step adds is only its place in the order, on the same thin-loader split as the overdue-date sweep above — behaviour in the composed artefact, sequencing in the task. **A dispatch ticket's named set is an input, never the scope.** A `DISPATCH:` or batch-review ticket that enumerates the queue's members, and yesterday's entry's own count, are both read **last** and only to reconcile against the derived set; neither ever stands in for the read, however recently it was written. A count carried forward from either is reported as suspected-incomplete, naming what it covered, and is never handed up as the queue.

(Worked case, **reported** from the filing leg's Linear reads: the 2026-10-19, 2026-10-20 and 2026-10-21 `a1.standup` entries each carried the A1 review queue at three to four items, re-checking only the four tickets `A1-594` names, whose own title additionally reads "9 items, unchanged since 2026-10-02" — a stale reference inside the stale input. The 2026-10-22 run ran the read as the rule defines it and returned **13** for the A1 bucket alone. Ten of the thirteen are new DS-check and fix tickets from the 2026-10-21 Meirion design-system sweep, which landed straight into In Review carrying `human` from their template, so the growth is real and the narrow read is the defect. Fourth instance of this root after APP-1888 and APP-1967, the MRP review-queue undercounts, and APP-2336 / APP-1963, the Apps scope-count drift. The shared rule has been live in `skill-operating-loop` throughout, so what is failing is this loader's inheritance of it rather than the rule — APP-2584.)

**Run the silently-held operator-queue backstop as an ordered step of the daily pass — workspace-wide by label, never team-scoped.** The two steps above order the date sweep and the review queue; the operator-queue backstop is the third read the loop owns and the only one of the three this loader has never sequenced. **Its recipe stays in `skill-operating-loop` and is neither reproduced nor paraphrased here**: read it from there and run it as written. What this step adds is its place in the order and the one property the read keeps losing — **the scope is the workspace, filtered by the vertical's `operator` label, and bucketed by team afterwards, never a read scoped to team A1**. A team-scoped read cannot see an `operator-a1` member sitting in another team, and it fails in the flattering direction: it returns a well-formed, plausible set, so the entry reads complete, and a member missing from it has nothing else watching it. So today's entry **names the scope the read actually used**, and a read that turns out to have been team-scoped is reported as suspected-incomplete rather than handed up as the queue. (Worked case, **reported** from the filing run's own Linear reads: `APP-1226` carries `operator-a1`, no executor and Blocked, which puts it in A1's operator queue; the `a1.standup` entries for 2026-10-28, 2026-10-29 and 2026-10-30 all leave it out, and the 2026-10-30 entry states that its silently-held read covered *"team A1 across Blocked/In Review/Todo/In Progress"* — `APP-1226` sits in the **Apps** team, so that read could not see it. The 2026-10-26 entry did read workspace-wide and did find it, so the scope narrowed again after that; a `list_issues(label: operator-a1, state: Blocked)` read at 08:4xZ returned `A1-545`, `APP-1226` and `A1-774` as the no-executor members. Third instance of this root after APP-1933 and APP-1843, both closed, so what is failing is this loader's inheritance of the rule rather than the rule — the same diagnosis the two steps above already carry. APP-2773.)

**Re-derive the operator-routed Blocked queue line as an ordered step of the daily pass — fresh from this run's own label read, never carried forward.** The three steps above order the date sweep, the review queue and the operator-queue backstop; the operator-routed Blocked queue line is the one `skill-operating-loop` calls the stand-up's primary input, and the only one of the four this loader has never sequenced. **Its recipe stays in `skill-operating-loop` and is neither reproduced nor paraphrased here**: read it from there and run it as written, and name in the entry which test produced the line. What this step adds is its place in the order and the one property the line keeps losing — it is derived from the label read this run performed, and a line carried unchanged from an earlier read is not a re-derivation. The asymmetry earns the step because the two errors cost differently: re-deriving a line that turns out empty costs one query, while a line copied forward reports delivery work as pending judgement and inflates the single count the stand-up acts on, in the flattering direction — it reads complete and plausible to anyone holding only the prose. The unsequenced read is the one that fails, and it fails beside a sequenced read that held: one entry can state the backstop correctly and copy the queue line forward two lines later. (Worked case, **reported** from the filing leg's document reads: the 2026-11-13 08:17Z `a1.standup.2026-W46` entry listed `A1-543`, `A1-362`, `A1-429`, `A1-1` and `A1-879` under *Operator-routed Blocked queue* as "carried unchanged", all five carrying an executor — four `human`, `A1-362` `R3-LAY` — while the same entry's sequenced backstop line was right and the workspace-wide queue read at 08:3xZ returned the A1 queue empty. Sixth consecutive run of this shape and the first after the queue-test clause landed in `skill-operating-loop` on 2026-11-12, which is why the step is sequenced here rather than the rule restated there — `APP-3090`, inside the Owner ruling that scope and queue are two different reads of the label, Aled 2026-09-04, `APP-1117`.)

## Step 3 — Escalate only the urgent edge

The daily pass surfaces to Aled's stand-up; a genuine mandate-edge item that cannot wait for the weekly session (a strategic pivot, a budget-envelope breach, a goal-set change) is raised to the Owner with a recommendation, never actioned. Everything else waits for the weekly strategic session.

## Step 4 — Capture friction

On finish, run `skill-ops-retro` capture on this run's friction: search the Pulse queue first and add evidence to a same-root note if one exists, otherwise file a `FRICTION:` note for the drain to assess.

---

*To change behaviour, edit `skill-operating-loop` (or the mandate in `operator-a1`), not this file. This task carries no behaviour beyond loading and sequencing them. Daily sibling of the weekly `task-a1-operator-loop`.*
