---
name: "task-apps-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 Apps accelerator on behalf of operator-apps, feeding Aled's 09:00 stand-up. Loader only; behaviour lives in skill-operating-loop (The two cadences) and skill-portfolio-allocation, the mandate in operator-apps. 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-apps-operator-loop)."
license: CC BY-NC-SA 4.0
---

You are running the **daily shadow stand-up** for the **Apps accelerator** on behalf of **operator-apps**. 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-apps-operator-loop`), never here.

## Step 1 — Load the context

Read and follow, in order:
* `operator-apps` — the mandate, remit, escalation anchors, and reporting targets.
* `skill-portfolio-allocation` — the allocate-across-bets frame; the daily pass reads each bet's movement tactically rather than re-running a full allocation.
* `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

**Before the pass — re-derive the carry set mechanically, before a line of prose is written.** The carry set is derived from the tracker on every pass and never inherited from the previous entry's wording. The rule is `skill-operating-loop`'s (*The two cadences*, the MRP-51 worked case); what follows is its execution, written as an ordered step so it is run rather than kept in mind. All three reads happen before anything is drafted:

1. The vertical's open **Backlog** items, oldest `createdAt` first.
2. Every item carrying **`agent:R3-LAY`**, in any state, oldest `createdAt` first.
3. Yesterday's `apps.standup` entry — read **last**, and only to see what it said. Never the source of the set.

Then reconcile in the entry, in both directions:

* An item returned by (1) or (2) that yesterday's entry did **not** carry is **named in today's entry**, with one line on why it is still open and what moves it. An item a previous pass explicitly declined to action is carried on exactly this footing — a decline is not a close, and the decline is the line.
* An item yesterday's entry carried that (1) and (2) no longer return is stated as **resolved**, naming what resolved it, rather than dropped silently.
* A read that returns nothing says so: the read ran and returned nothing. Otherwise silence and no-read are the same transcript, which is the failure this step exists to remove.

Why the step sits in the loader and not only in the rule: the rule was already in canon and the per-vertical loaders were not executing it. `apps.standup` carried APP-1530, the one-time `operator-apps` backfill, on the 2026-09-18 and 2026-09-21 entries and then dropped it from 2026-09-22, 09-23 and 09-24, while it sat untouched in Backlog under `agent:R3-LAY` throughout — a 2026-09-24 `[triage]` comment declining to action it did not carry it either, and it resurfaced only when a later run re-derived the set from the tracker rather than from the previous entry's prose. `mrp.standup` did the same with MRP-57 and MRP-58 across the 23 and 24 September entries. Two verticals inside one week, on a rule written for both, so what failed is the loaders' execution rather than one vertical's lapse. An item that leaves the entry chain by omission has nothing to bring it back, and the failure reads clean from either end. The sibling loaders — `task-mrp-operator-standup`, `task-a1-operator-standup`, `task-bottrader-operator-standup` and `task-bara-operator-standup` — carry the same gap and take the same step. (APP-1764, APP-1669.)

**Re-verify a carried characterisation against the live thread before restating it — an ordered step, run at the point the bullet is composed.** The step above re-derives *which* items carry. It says nothing about the words attached to them, and the words are what the entry actually hands up. A judgement like *"a better candidate for cancellation than for review"* is written once from a reading of the board, then copied forward with only the day-count incremented, and every later entry reads as freshly assessed while nothing has re-tested the premise. So before this entry restates a characterisation a previous entry made — stuck, stalled, a cancellation candidate, waiting on someone, superseded, needing a tidy-up close — read that ticket's **own comment thread to the end** and either restate it citing the thread's newest ruling, or replace it with what the thread now says. A characterisation that survives its second restatement unverified is a defect in this entry, not in the ticket. Where the thread shows the item correctly at rest — a human-only completion step, an Owner-held decision, a leg that closed the question and said so — the entry says that and stops reporting it as stuck, which is `skill-operating-loop` step 3's repeated-flag conversion doing its job rather than a third restatement of the flag. The sibling daily stand-up loaders carry the same gap and take the same step. (Worked case, **reported** from the filing run's own thread read: the `apps.standup` entries for at least 2026-10-26 through 2026-10-29 each restated APP-125 — app.fitness, "Draft the privacy policy", In Review — as *"a better candidate for cancellation than for review"*, incrementing only the day-count, with no re-read and no conversion to an action or an escalation. Read to the end on 2026-10-30, the ticket's twelve comments show the loop's own merge leg closing the question on 2026-10-20 — a `[merge]` No-PR exit, relabelled `human`, *"nothing further from the loop; closing this is yours"* — following the Owner's 2026-10-19 approval, with three placeholders only Aled can supply before hosting. The ticket was resting correctly as a human-only completion step the whole time. Instance seven of this root after APP-1810, APP-1935, APP-2337, APP-2398, APP-2010 and APP-2136, all closed on the MRP and BARA stand-ups, which is why the check is written here as a step rather than left in the rule. APP-2771.)

**Write every ticket reference as a bare identifier — an execution step, not a background rule.** While each bullet of the entry is composed: write the ticket's bare identifier as plain text (`APP-1234`, `MRP-57`) and let Linear resolve it on save. Never compose an `<issue id=…>` tag by hand, never fill one with a placeholder or invented UUID, and never take the markup shape of a reference from the previous entry's bullets. The rule itself is `convention-linear`'s and is not restated here; what this step adds is its **position** — at the point of composition, in the file this run reads, rather than in a convention loaded whole at Step 1 and never re-consulted sentence by sentence while the entry is written. That is the same remedy, on the same diagnosis, as the paragraph above, which is cited rather than repeated: *"Why the step sits in the loader and not only in the rule: the rule was already in canon and the per-vertical loaders were not executing it."* The sibling daily stand-up loaders carry the same gap. (Worked case, **reported** from the filing run's own reads: the 2026-10-21 `apps.standup.2026-W43` entry hand-typed `<issue id=…>` tags with fabricated placeholder UUIDs ending `-0000-0000-0000-000000000000` across seven references. It is the fourth dated instance of one root — 2026-09-11, 2026-10-08, 2026-10-13, 2026-10-21 — and the first to land **after** the `convention-linear` fix, six days inside that fix's own 2026-10-30 by-when, so what failed is the rule's placement rather than its wording. APP-1326, APP-2166, APP-2512.)

**Linear's save-and-read-back self-heal is reported, unverified, and not a safety net.** The same run reports that replacing its fake tags with bare identifiers and re-reading the document found Linear had re-expanded them into full `<issue id=…>` tags whose UUIDs and hrefs matched the tickets named. That is a claim about the connector's own mechanism drawn from **two references checked closely**, so it is recorded as reported and **unverified** and nothing above is relaxed for it: a sample of two does not establish the behaviour, and a hand-authored tag whose invented UUID resolves to an unrelated real ticket is a worse failure than a dropped one, which is the failure APP-1326 already names. The instruction stays write-the-identifier, whatever the save does afterwards (APP-2512).

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, **`apps.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. As a portfolio operator, compress per bet before writing: the three lines that need Aled, not the Pulse queue's volume.

**The status-update read has a recipe, because here a read that finds nothing is the failure mode, not a read that finds the wrong thing.** The recipe cited above — `skill-operating-loop`'s *The two cadences* — governs **ticket** reads and says nothing about status updates. Three parts. (i) **The call and its scope** — `get_status_updates`, once per Apps-portfolio project; `convention-linear` and `convention-agent-runtime` are the two artefacts that carry the tool and its arguments, so cite them rather than restating. (ii) **A freshness test against today's London date, not against an elapsed window.** A brief created today is fresh however few minutes ago it posted: `task-daily-report` and this stand-up both run weekdays on Europe/London crons, and the producer's start is scheduled ahead of this stand-up's — but that is a fact about **starts**, not about when the briefs exist, and the producer's run is long enough to overlap this one, so **the order in which the two land is not guaranteed** and must not be assumed in either direction (`APP-3064`). Derive both cadences from the scheduled-task store at the moment you need them, never from this paragraph and never from a previous entry; read there, the producer's cron is `0 8 * * 1-5` and this stand-up's is `10 8 * * 1-5`, and on 2026-11-12 the producer fired at 08:02:50Z and did not finish until 08:23:30Z while this stand-up fired at 08:10:40Z — that is the overlap, measured rather than assumed. A stand-up reading inside it must **expect briefs minutes old** and must not read recency as absence. (iii) **What to say when none is found** — name the projects read and the absence, with the read's own time, rather than silently citing an older brief. **It fails in the flattering direction, which is why it has to be written down rather than left to judgement:** the stand-up runs on time, writes on time, and cites *a* brief, so every surface reads healthy while the status input is a day or more stale and the consolidated agenda corrects it by hand each morning. The stand-up itself never fails, so the cost is invisible from the stand-up and visible only one level up. (Worked case, **reported** by the `task-owner-standup` leg from reads on 2026-10-20 and **not re-read from a canon drain's surface**: `apps.standup.2026-W43`'s 2026-10-20 entry, written around 07:16Z, said *"no fresh morning project-status briefs had posted for Apps-portfolio projects at the time of this run"*, while the briefs for os.Claude, app.Triage, app.AgentArt and osclaude.vitals had been created at 07:11:23–07:11:31Z — about five minutes earlier. The 2026-10-19 entry cited the 16 Oct briefs against that day's postings at around 07:23Z. Two consecutive days. **Observed** from live canon: `get_status_updates` appears in two artefacts across the store and in none of `task-apps-operator-standup`, `task-daily-report` or `skill-operating-loop`, so no operator stand-up was told how to fetch the briefs it is told to read. The schedule was never the defect — `task-daily-report` prescribes the ordering that was in fact observed. `APP-2480`.)

**A brief that does not exist yet is a third state, and it is not absence.** The `APP-2480` test above covers a brief that is *minutes old* and tells this pass not to read recency as absence. It carries no branch for the brief that has **not yet been posted at the moment of the read** — distinct from fresh and distinct from genuinely missing, and it is the state that produced the case below. So: where a brief is absent at the moment of the read **and the producing run's own window has not closed**, the entry reports it as **not yet posted at `<time>`**, naming this read's own time and the producer's cadence as read live from the scheduled-task store, and never as **absent**. *Absent* is a claim about the producer having failed; *not yet posted* is a claim about this read's timing, and only the second one is true. This **extends** the `APP-2480` remedy and does not replace it — that freshness test still governs the brief that does exist and is merely fresh. The deeper remedy is **scheduler ordering, which is configuration and not canon**: it is not authored here, and it is named for the Owner. (Worked case, **reported** from the filing leg's own `get_status_updates` reads and **not observed here**: on 2026-11-12 this stand-up read for the day's morning briefs at about 08:12Z and saved its entry at 08:17:48Z recording the briefs as absent, while `task-daily-report` posted all 22 of them at 08:19–08:21Z, after the entry had already been written. `task-owner-standup` reconciled it, but only because it runs later in the day. Recurrence of `APP-2480`, closed. `task-daily-report` separately already holds that its schedule *is a guarantee about when this run starts, never about when its updates exist* (`APP-2838`), which is the same point from the producer's side. `APP-3064`.)

**State the Owner-session outcome — in every entry.** This vertical's Owner session sits on **Wednesday** (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 `apps.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.

## 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.

## Step 5 — Capture telemetry

As the true final step, after Step 4, read the canon artefact `skill-telemetry-capture` (the saved skill of that name; locally at `.claude/skills/skill-telemetry-capture/SKILL.md`) and follow it verbatim, passing `task: task-apps-operator-standup` and this run's own `outcome` (e.g. `completed`, `blocked`).

---

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