---
name: "skill-operating-loop"
type: skill
description: The operator's standing cycle, run in the context of a single vertical — read the goal and KPIs, assess against target, decide the next best actions, dispatch through Relay to the functional fleet, escalate only at the mandate's edge, and report status in the standing operator format. Use whenever an operator drives its vertical forward (typically the weekly loader such as task-bara-operator-loop), or on demand to push a vertical toward its outcome. Venture-agnostic; the mandate and sources are supplied by the operator instance.
license: CC BY-NC-SA 4.0
---

# operating-loop

The behaviour an operator runs to drive its vertical toward the mandate's outcome. Agnostic — the operator instance (`operator-bara` and future siblings) supplies the vertical, its goal and KPI sources, and the mandate envelope. This is the Layer 1 behaviour beneath `workflow-venture-operating-loop`; it composes Atlas (planning) and Relay (delivery flow) rather than re-implementing them.

## Trigger

Run by an operator's scheduled loader (weekly by default, e.g. `task-bara-operator-loop`), or on demand when an operator needs to move its vertical. When the Owner invokes the operator in an interactive session, it drives its own delivery in that session rather than filing the work for the scheduled loop (step 4). Requires an operator context: the vertical, its mandate — goal source, timeframe, envelope and spend-to-date, read from the vertical's standing mandate document rather than from figures in the profile — and its declared State sources (goal, KPI, analytics, and the Linear board scope).

## Behaviour

One pass of the loop:

1. **Read the state.** Load the vertical's mandate first. The mandate's *values* — timeframe, envelope, spend-to-date — are read from the vertical's standing mandate document, `<vertical>.mandate`, on the vertical's initiative (`bara.mandate` is the first instance), never from figures written into the operator profile: the profile names the source, as it already does for goal and KPIs, so a change to the envelope or the window is an edit to that document by the Owner, not a canon change through the Pulse queue. The Owner owns the envelope line; spend-to-date derives from the vertical's cost tracking once it exists (BARA: MBN-263), and the operator writes nothing into the document. An envelope belongs to a scope, not to an operator, which is what lets an operator holding two mandates read two documents rather than be rewritten. (Worked case: `operator-bara` carried "envelope zero" and "roughly four to five weeks" as literals while the Owner had granted £500 on 2026-08-10 and the window had moved twice, to 2026-11-14 and then 2027-02-26 — every loop read a superseded mandate. APP-1064.) Then load the goal and KPIs from the operator's named sources — the strategy docs, the live analytics, and the **State sources** the profile declares (`convention-artefact-format`, operator skeleton): the dashboard artefact by id where one is named (`operator-bara` names `bara-dashboard`), otherwise the declared Linear board scope — team, projects in scope, initiative — read directly. The board read is the sanctioned path where no dashboard exists, not a silent shortfall; a profile that declares neither fails the profile checklist, and a vertical whose KPI tree is unset says so on that line rather than omitting it (APP-980). Read where the numbers stand, not where they were assumed to be.

   **Then read what this cycle committed to — the loop's only input with a number and a deadline.** The mandate and the KPI sources move slowly and rarely produce a verdict; the cycle commitment is set fresh each boundary and can be missed outright inside a single period. So after the goal and KPI sources, read the vertical's **current cycle** and its **committed list** — the per-cycle goal document `<team>.cycle-goal.YYYY-Www` that `task-cycle-planning` writes at proposal time and the Owner approves, which is where the commitment lives and is why it is never read out of a deliverable's description — together with the cycle's `issueCountHistory`, `completedIssueCountHistory` and scope, which cost one `list_cycles` call. A vertical whose cycle carries no goal document says so on this line, exactly as an unset KPI tree does, rather than omitting it. (Worked case: at the W39 boundary on 2026-09-21 the Owner set Mr Pritchard's commitment — one Substack post and two LinkedIn posts — recorded in exactly one place, the `## Why` section of MRP-56's description. The weekly report written the same day reported objective 2 as untestable until launch, when two LinkedIn posts need no Substack publication and the objective was testable that morning; cycle 12 closed 2026-09-27 with 0 of 11 issues and 0 of 26 points, the second post never ticketed, and the miss surfaced only because a reader opened MRP-56 while chasing an overdue date — APP-1813.) **Then name every dated commitment falling inside the cycle window, and check the committed list against it.** The read above establishes what the cycle *did* commit to; nothing in it asks what the window *contains*. So list the vertical's goal, objective, milestone and gate target dates falling between the cycle's `startsAt` and `endsAt` — the charter and the milestone list are already open for the reads above — and name any that sits in neither the committed list nor the document's explicitly-excluded list as its own finding, on the same footing as a cycle that closes with zero completions. An objective with a date inside the window is committed, deliberately excluded with a reason, or escalated; it is never simply absent. The whole cost is one line saying what the read found, and the failure it catches is silent in the expensive way: the cycle reads healthy, the goal is coherent, the exclusions are reasoned, and the objective expires with nobody having decided to let it. (Worked case: A1's cycle 12, 2026-09-27 to 2026-10-04, carried a well-formed cycle-goal document rewritten that morning with a five-item commitment, a held-back slot, an explicit exclusion list and a gaps section — and no mention of O6, `assoc.one` live by 1 October, whose gate fell on day five of eight. The gate milestone and both feeding it read 0%, and the four tickets beneath it had sat Urgent in Backlog for a week; the four named in the exclusion list were different ones. Caught only because the run happened to open the milestone list while assessing something else — `APP-1861`.)

 **And a commitment can go stale inside the cycle with nothing obliged to amend the document, so the committed tickets' own threads are read before the commitment is reported as live (APP-2645).** The two reads above establish what the cycle committed to and what its window contains. Neither asks whether a commitment still stands. A cycle-goal document is approved once and frozen, while the commitment it records can be withdrawn, deferred, half-discharged or falsified by events days later — recorded, if anywhere, in one comment on the committed ticket, with no state change and no ceremony between it and the next boundary. Every field a loop reads then agrees: the document is current, the cycle is mid-flight, the ticket is still Todo, still Urgent, still assigned, and the honest report is "committed 1, completed 0, day 5 of 8" — which reads as an ordinary in-flight miss. A withdrawn commitment and a missed one have different diagnoses and different remedies, and only the thread separates them. So where the document asserts a commitment, read each committed ticket's comments for a withdrawal, a deferral, a rescope or an Owner ruling dated inside the cycle window, and **report a commitment that no longer stands as its own finding**, on the same footing as a cycle that closes with zero completions. The tickets are already being opened to ground the agenda, so the marginal cost is the comparison rather than the read. This is the reader's duty and reaches no further: obliging whoever records a mid-cycle ruling to amend the approved document is a write into a committed artefact and is the Owner's to mandate, not this loop's to assume. (Worked cases: `mbn.cycle-goal.2026-W43` stated at top and bottom that MBN-321 was committed — the cycle's only MBN commitment, and the one item the document argued compounds rather than accumulates. The Owner withdrew it two days later at the 2026-10-21 stand-up, recorded in a single MBN-321 comment as deferred with no state change, and the document was never amended; MBN-321 is the decision that makes MBN-290's 2026-10-31 gate readable, and that gate releases or withholds £350 of a £500 envelope, so the cheapest route to an uninterpretable verdict on 1 November was a withdrawal nobody was obliged to notice. Two further faces of the same root at the W43 → W44 boundary: MRP-80's committed disposition rested on the premise that approving and posting were the same act, and what MRP-82 actually published on 2026-10-20 was different content entirely, leaving MRP-80 undischarged and In Review while the document still asserted otherwise; and A1-429's two-condition commitment was half-discharged on 2026-10-19 when the Owner separated sign-off from the remaining CMS work and logged D135, with the board showing one untouched Todo row. A first draft of `a1.cycle-goal.2026-W44` proposed a goal sized correctly from every field and wrong about the week, withdrawn and corrected in the same run; the correcting read was one `list_comments` call on a ticket the proposal had already named. The documents, comments and dates are the filing legs' **report** and are unverified here — APP-2645, with APP-2636 as the reporting-side instance of the same root.)
 **And a cycle-goal document that exists is not yet a commitment — test its approval status, not only its existence.** The existence guard above has two states, a document or none, and the staleness rule above tests the committed tickets' threads for a withdrawal. Neither reaches the third state, which is the common one: a document that resolves by name, is titled for the current ISO week, is parented to the right project, carries a present and well-argued committed list — and has never been approved. Every field the read returns agrees with a committed week, so the loop reports a proposal's list *as* the commitment and the *committed n, completed m* line is computed over a set nobody ever agreed to; the thread read passes cleanly precisely because there was never a commitment to withdraw. Being well-formed and current is what lets it through, which is the signature APP-2713 and APP-1768 carry on other surfaces. So the same read that opens the document tests its **approval state** off the document's own text — the proposal banner `task-cycle-planning` writes — and where it is unapproved, **reports that as its own finding**, on the same footing as a cycle closing with zero completions, naming the deadline the document sets for its own approval and how far past it this read is taken. Where the document sets no such deadline, the cycle's `startsAt` is the deadline. The cost is one comparison on a document already open. This is the reader's duty and reaches no further: approving the document, or amending it, is the Owner's act and `task-cycle-planning`'s record, never this loop's to assume. (Worked case, **reported** from the filing run's own document and cycle reads — `task-bara-operator-loop`, unattended cloud fire, 2026-10-30 12:17Z. `mbn.cycle-goal.2026-W44` opened with *"PROPOSED — NOT COMMITTED. Nothing has been written to any cycle. Awaiting your approval."* and closed with *"Unapproved after 2026-10-24 (the second day), this proposal is an open Owner decision."* — a date already six days past at the time of the read. MBN cycle 16, 2026-10-26 to 2026-11-02, read at the same time: 7 issues, 13 points, `completedIssueCountHistory` [0,0,0,0], day 5 of 7. The proposal's single MBN item is `MBN-321`, whose gate `MBN-290` fell 2026-10-31 and releases or withholds £350 of a £500 envelope. So the cycle ran five days with no approved goal while the document itself had already named the escalation condition it had met, and it was caught by that banner's text rather than by any rule obliged to test it. The `APP-2400` beat score has now been unavailable on MBN for two consecutive cycles for two different reasons — W43 stated its commitment as a list rather than numbered beats, W44 is uncommitted — which this finding makes visible rather than fixes. APP-2776.)
 **And a ruling recorded only in a cycle-goal document's amendment is a ruling the ticket has not received — scan the amendment for the identifiers it decides (`APP-2965`).** The staleness rule above reads a committed ticket's thread for a withdrawal; the approval rule above reads the document's own banner. Neither reaches a ruling the Owner gives as an *instruction to amend* the document: it lands in the amendment block and nowhere else, and the ticket it decides keeps the thread it already had. `APP-1478` closed the decision-log leg of this family and `APP-2537` the comment leg; an amendment is now the surface in routine use, because boundary proposals are amended on instruction rather than re-committed, so it is the likeliest place for a mid-cycle Owner ruling to live and the one place no read tests. Every guard then passes honestly — the thread is read correctly and does not contain the ruling — and the ruled item keeps being surfaced as an open ask, which costs the Owner the same question twice and costs the operator its credibility on the third asking. So on the read that already opens the current and previous cycle-goal documents, **scan each amendment block for the ticket identifiers it decides**, and for each identifier whose thread carries no comment dated at or after the amendment, **report it as ruled in document, unwritten to ticket** — naming the ruling, the document and the amendment's timestamp — then make the write-back inside the operator's own grant, or name who must. The test is **per identifier, not per amendment**, because one amendment writing back to one of the two tickets it decided is the observed shape, and a per-amendment test scores that amendment as recorded. The documents are already open, so the marginal cost is the comparison rather than the read. This is the reader's duty and reaches no further: obliging the pass that *writes* an amendment to carry a write-back duty belongs to that pass, and naming a cycle-goal amendment a valid-but-incomplete record is `convention-decision-log`'s *recorded* test to set, never this loop's to assume. (Worked case, **reported** from the filing note's own document and thread reads and unverified here: `mrp.cycle-goal.2026-W45` was amended on the Owner's instruction, 2026-11-03 09:34Z, and ruled that `MRP-80`'s opener no longer held the week's slot. `MRP-97`, decided by the same amendment, had the ruling written to its thread at 09:34:29Z; `MRP-80` did not, and its newest Owner word stayed 2026-10-14 with no state, priority, label or assignee change and no comment. Three later surfaces then read that thread correctly and reported the world wrongly — the 2026-11-06 boundary proposal asked for `MRP-80`'s disposition, `mrp.standup.2026-W46` recorded it 2026-11-09 08:36Z as unchanged with no new replies, and the 2026-11-02 agenda's Async table carried it as awaiting one word — until the 2026-11-09 weekly loop recorded the ruling onto the ticket by hand. `APP-2965`.)
 **And a named state source that does not exist is a defect in the pointer, not a figure that went unread (`APP-3072`).** The existence guards above each have two outcomes — the goal source resolves or the line says the KPI tree is unset, the cycle-goal document resolves or the line says the cycle carries no goal document — and a source that merely went stale lands on the same branch as a source that was never created: both are honestly reported as not read, on every pass, and neither branch ever asks whether the *pointer* is wrong. Staleness ages and clears; an absent source does neither, so no age test can ever retire it, and the not-read line stays correct forever while the loop reads nothing at all. So where a named state source is **absent** — no document resolves under that title on the vertical's initiative and none resolves workspace-wide, as against a document that does resolve and is old — the loop distinguishes that from staleness and surfaces the pointer itself as the defect, naming the artefact that names the source, the titles that resolve to nothing, and how long the surfaces reporting against them have been doing so, rather than reporting the figures as not-read a further time. Where the loop can see what the authoritative source *should* be — typically the owning initiative's own description — it says so in the same breath, so the finding carries its own repair. (Worked case: `operator-bottrader` pointed step 1 at two mandate documents, `bottrader.mandate-a` and `bottrader.mandate-b`, neither of which has ever been created — `list_documents` on initiative `bot.Trader` (`I-12`) returns two other documents and a workspace-wide query returns zero, verified live on 2026-11-13 — and the pointer survived from 2026-09-14 to 2026-11-12, roughly two months, with every intervening run reporting those mandate figures as not read and behaving correctly in doing so, which is why no run ever produced a signal. `APP-3072`.)
2. **Assess against target.** For each KPI, is the vertical on, ahead of, or behind target for the timeframe? Name what is drifting and why, in one line each. **Then one line against the cycle: committed *n*, completed *m*, and what is carried** — the only line in the report with a real denominator where the KPI tree is unset, which is the ordinary case while a cascade is unbuilt. **A cycle that closes with zero completions is named as its own finding**, on the same footing as step 7's unexpectedly-old-predecessor rule: zero throughput across a whole period otherwise reads as ordinary red and is indistinguishable from slow progress (APP-1813).

   **And the goal is scored by its beats, never by its tickets (Owner ruling, Aled 2026-10-19, APP-2400).** A cycle goal's pass condition is written as **numbered, independently checkable beats**: one condition each, scorable met or not met at the close without reference to the others. A pass condition that cannot be scored as *n of m* is rewritten before the commit is proposed, by whichever surface drafts it — `task-cycle-planning` at the boundary, or the operator supplying its vertical's wording. The cycle line then reads `goal <met>/<total> beats; say/do <landed>/<committed>`, with the two kept apart, because they diverge: A1's W42 met both its beats with none of its five committed tickets Done (`data/planning/a1/2026-W42.json` in `assoc-one/claude-ops`, read on `origin/main` `dc16455`, 2026-10-19). The score and its record belong to `task-cycle-planning` (*The planning-week record*). This loop reads them and never writes them.
3. **Decide the next best actions.** Choose the highest-leverage moves for this cycle — tactical choices (campaign, channel, sequence) are the operator's to make freely. If the *strategy* itself looks wrong (not a tactic), refresh it with **Atlas** — but a genuine strategic pivot is an anchor: flag it, do not enact it (step 5). **Read the lanes from the executor label, never the assignee.** Whenever steps 2–3 count what is blocked, what is the fleet's and what is the operator's, lane membership is read from the `agent`-group label — `human` is the human lane, a functional `agent:*` value is the fleet's — and never from the assignee field. The assignee is *who is looking at it*; the label is *what surface runs it*, and on this board the Owner is routinely the assignee of tickets the fleet executes. Three consequences: (a) a ticket with a human assignee and **no `agent`-group value is unrouted**, a triage defect raised to Relay in this pass, not evidence of a human-lane constraint; (b) a ticket carrying `human` wholesale whose action is only *partly* the operator's (a Shopify-admin install plus a connector-side diagnostic) is **split** into a `human` leaf and a fleet leaf, the same shape `convention-secrets` sets for credential-gated work; (c) "the human lane is the binding constraint" is the loop's most consequential report — it stops dispatch and sets the Owner agenda — so it is asserted only from the label read. And separately: **an observation repeated across runs without an owner becomes work or stops being reported** — a "flagged for Relay, not acted on" line that appears in three consecutive updates is either raised as a ticket this pass or dropped. (Worked case: three BARA loops, 2026-08-14 / 17 / 22, reported "every remaining Phase-1 item is in the human lane"; read against labels, MBN-263 carried no `human` at all and MBN-264 was two tickets wearing one label — APP-1039.)
4. **Dispatch through Relay.** Turn the chosen actions into work and route them via **Relay** to the right functional agent (Forge to build, Reach to market, Pixel/Sonar for brand and discovery). The operator commissions and sequences; it does not execute the functional work itself.

   **Invoked in an interactive session, dispatching means driving (Owner direction, Aled 2026-10-19, APP-2427).** Where the Owner opens a session and invokes the operator in it, rather than a scheduled loader firing it, the operator does not stop at filing work for the delivery loop to pick up later. It runs the work as far as it can without him, acting as that session's driver. Relay triage, each Forge exec leg (in a worktree where the surface offers one), each Prism QA leg, the route step and the Relay merge leg are each run as a separate, tool-scoped subagent under `routine-delivery-loop`'s leg discipline and `convention-agent-runtime`'s isolation rules, with Prism never sharing Forge's context. It stops only at a genuine human-review criterion, a blocker, or the canon gate, which is the Owner's save and never a leg's write. Three things do not change. The operator still executes no functional work itself. It **never merges**. And it **never asks the Owner to signal a merge that needs no judgement of his**. Where no human-review criterion is met and Prism is clean at the live head, it routes the ticket to `agent:R3-LAY` and runs the Relay merge leg, exactly as the loop's route step does (`skill-merge-pr`, *Context*; Owner direction, APP-1756). Where a criterion is met, the ticket takes the flagged route to the Owner. Both failures happened in one session on 2026-10-19 on `assoc-one/claude-ops#464`: the operator first asked the Owner to signal a no-judgement merge, then merged the PR itself. The Owner corrected both. Work the session cannot finish — a criterion met, a blocker, the session ending — is left in the state a scheduled run would have left it, and the session's report names the hand-off. The scheduled loader is unchanged: unattended, the operator dispatches through Relay and the delivery loop picks the work up. (Worked case: the 2026-10-19 Apps operator session filed APP-2423 to APP-2426 to Relay's Backlog and declared itself closed. The Owner's direction was *"in instances like this I want you to run it as far as you can without my intervention"* — APP-2427.)

   **Before routing work to an executor value, confirm that value is consumed (APP-2439).** A dispatch to a **delivery** executor has a delivery test — `skill-build-ticket`'s claim gate bounces a malformed ticket and the delivery loop's states move, so the dispatching loop learns inside a cadence. A dispatch to a **horizontal or planning** executor has none of that, and the ticket then sits in the one shape every read treats as healthy: correctly routed, correctly labelled, top priority, and unconsumed. So before the route is written, two things are confirmed, both from canon rather than from the board — that **some skill reads a queue filtered by that executor value**, and that the work falls **inside a slice that executor's profile declares live**. Where either fails, the route is a **no-op that looks like progress**, and it leaves the ticket worse off than not routing it at all: `convention-linear`'s ladder climbs on age to Urgent, which is the top rung, so the ticket ends at the top of the escalation ladder with nowhere left to climb and nothing reading it, and the longer it sits the more settled it looks. Where no consumer exists the move is not a dispatch: **name the missing consumer as the work** — a loader scope change, or a different route — and leave the ticket in a lane that is at least being read. A re-test one cadence later is not the remedy; it detects the no-op a week after the dispatch instead of preventing it. (Worked case: on 2026-10-12 `operator-mrp` routed MRP-19 — the Mr P KPI cascade — from `human` to `agent:ATL-4S` under the Owner's own W42 cycle-goal directive, and recorded it under *Decided*. Read again 2026-10-19: still Todo, Urgent, unassigned, no comment, no KPI tree — seven days. Measured across canon on 2026-10-20, **all 11 `ATL-4S` occurrences are identity, ownership or registry statements** — `agent-atlas`, `core-fleet-roster`'s row, `core-operating-model`'s branded-form list, `convention-linear`'s label registry, and six *Owned by Atlas* lines — and **no skill reads a queue filtered by `ATL-4S`**, `task-cycle-planning` included. `convention-linear` also records Atlas as holding **one slice live** — cycle review and commit proposal, propose-only on cycle membership — so building a KPI tree was outside it twice over: no consumer read the value, and the work sat outside the one live slice. The *Decided* line was wrong the moment it was written — APP-2439.)
   **And the test binds every surface that writes a route, not only an operator dispatching (`APP-3094`).** The rule above reads as a dispatch rule, so it binds the operator deciding where work goes and nothing else — and the commonest route in the estate is not written by an operator at all. It is written by a functional agent opening a child ticket for the next agent in the chain, under a skill whose hand-off step names the executor and says nothing about whether that executor's queue is read. A child ticket one functional agent opens for another inherits the parent run's correctness and none of its obligations, so the consumption test is discharged for the dispatch and skipped for every route the dispatch produces. The asymmetry earns the extra line because the inherited case is the one that looks safest: the parent run confirmed consumption from canon and said so in its own description, which reads to a later pass as the whole lane having been checked. So any surface writing an executor value onto a ticket — an operator dispatching, a skill's hand-off step, an agent opening a child — runs the same two confirmations from canon before the value is written, and where either fails it names the missing consumer as the work rather than writing the route. (Worked case, **observed** against the synced store on 2026-11-16: `DR-4FT` occurs in **ten** artefacts and in **zero** of `skill-fleet-dispatch`, the only sweep that reads the connector fleet's boards — its *Runs* line names `P1-XEL`, `R3-ACH`, `SO-N4R`, `SC-0UT`, `A1-DE` and no more — so Draft's identity, ownership and registry statements exist estate-wide while no artefact dispatches its queue. On 2026-11-07 Reach, running `MBN-347`, opened `MBN-349` and routed it to `DR-4FT`, the correct executor by remit; it sat Todo, Urgent, correctly labelled, with zero comments and zero state changes for six days, in week one of a four-week organic test, and was found only when an unrelated cadence re-read the dispatch rows. The parent dispatch had confirmed `R3-ACH` consumption from canon; the child it opened confirmed nothing, because nothing asked it to.)
   - **And a delivery dispatch that is never claimed is the same no-op, so claim latency is tested on the next pass rather than assumed away (`APP-3035`).** The sentence above rules a re-test out as the *remedy* for the horizontal case, and rightly: there, canon can answer at route-time whether a consumer exists, so detection a cadence later is a weak substitute for prevention. A delivery lane is the opposite shape — the consumer exists by construction, and the only readable fact is whether it consumed — so for a delivery dispatch a later read is not a substitute for prevention but the only signal there is. The exemption at the head of this rule rests on a delivery test that fires **only if something claims**: `skill-build-ticket`'s claim gate bounces a ticket that is offered to it, and the delivery loop's states move once something starts. A dispatch nothing ever picks up fires neither, so the premise that the dispatching loop *learns inside a cadence* is false in exactly the case the exemption covers, and an unclaimed delivery row is indistinguishable from a dispatch never made. Nothing else carries the fact: `skill-fleet-dispatch`'s *Every ticket this run dispatched must have left Todo* is an end-of-run check inside one run and cannot see a lane across cadences, and measured across the synced store on 2026-11-11 the term *claim latency* has **zero occurrences**, so no rule names it as a thing to test. So **each pass re-reads the delivery rows it dispatched in the previous cadence and names any still unclaimed as its own finding** — lane, ticket, dispatch date and elapsed cadences — on the same footing as a cycle closing with zero completions; and the finding is about the **lane, not the ticket**, so the move is to name the lane that is not consuming rather than to re-prioritise the row, which `convention-linear`'s ladder has already climbed to its top rung. A row whose own body, or whose owning project's `status`, states a live hold is **not** a finding: `convention-linear` already holds that age is evidence of a stall only where nothing in the ticket explains it, and a stated hold is an explanation. Whether `APP-2439`'s consumption test should extend to delivery executors *before* the route is written, and who owns fleet claim throughput across verticals, are both the Owner's and are named here rather than ruled. (Worked case, **reported** from the filing note's own board reads and unverified here — `task-a1-operator-loop`, unattended cloud fire 2026-11-10, board reads 12:1x–12:3xZ: **four rows across three lanes** took a dispatch and consumed none of it for a week, every one Todo and unclaimed — `A1-825` and `A1-881` on `PR-1SM` at 12 and 5 days overdue, `A1-874` on `DR-4FT` at 6 days overdue after two unanswered chases, and `A1-883` on `F0-RGE` at 4 days overdue. The routing was correct on all four and the lane was the problem, and the dispatching loop learned it only because an unrelated run happened to re-read the rows. The note's fifth row — the `SO-N4R` set `A1-826`, `A1-827`, `A1-828`, `A1-829` — is **deliberately not counted**: `skill-fleet-dispatch` records that set as a deliberate hold with a stated reason, held across three sweeps, which is precisely the explanation the age rule above requires. `APP-3035`.)
5. **Check the mandate edge — and take the calls that are yours.** Before anything proceeds, test each action against the three hard anchors: a **strategic pivot**, a **budget-envelope breach** (spend beyond the figure in the mandate document), or a change to the **goal set**. Any that trips an anchor is **escalated to the Owner with a recommendation** — assigned, with the reasoning — and held until the Owner rules. There is no fourth anchor. Below the anchors the operator's decision right is a **positive grant, not an exclusion list** (Owner decision, Aled 2026-09-03, APP-962): the operator decides anything that is **inside its vertical**, **reversible or bounded in cost** (the load-bearing test — if it cannot be unwound it is the Owner's whatever its category), and **consistent with its goal and mandate**. Concretely it may re-scope or waive a criterion, re-sequence committed work, choose a mechanism where canon already leans, and rule artefact placement and delivery shape. **The same grant makes the operator the first escalation target for its vertical.** A delivery leg that reaches a question routes it here, not to the Owner, and the operator sorts it into one of five categories: **strategic context** (does this criterion earn its delay, does this scope change alter what is measured), **how and where**, and **prioritisation within the mandate** are the operator's to rule; **human faculties** (eyes on a rendered surface, a credential, host or physical access, anything irreversible or public) and **authority** (money, a mandate change, security posture, real-consequence accountability) go to the Owner, always. Every ruling is **logged with a citation** (the APP-948 rule — an operator's own ruling without a written source is as void as an asserted Owner one) and the consequential ones are brought to the weekly session under step 8 against goal progress. What fails a grant test is **forwarded, never sat on**: one comment naming the category and the failed test concretely ("irreversible: this changes a client-facing price", not "needs your call"), then assign Aled — a forward naming no failed test is by construction an over-forward the Owner may return (`convention-comms-owner`, *The forward format*). "Is it customer-visible" is not a test in canon, and applying it is what put a reversible, zero-cost navigation fix (MBN-267) and a CI-green merge (MBN-266, nineteen days at gate) behind an Owner word while none of the seven items in his lane on 2026-09-01 tripped a real anchor (APP-1064). Three further standing grants, ruled on 2026-09-01 for BARA and generalised on 2026-09-02, keep reversible work out of his lane:
   - **Reversible and zero-cost acts proceed.** Where a move is reversible, spends nothing against the envelope, and implements a plan the Owner has already ruled, the operator acts and reports it under *Decided*. It does not ask.
   - **Folded default on an aged gate.** Where a gate item the operator has surfaced with a stated recommendation sits unruled past five days, the recommendation becomes the default and runs, with the Owner holding a veto rather than a gate — `convention-ticket`'s Pattern A folded validation, extended from ticket confirmations to Owner gates. Three exclusions, stated in full: anything that spends money, anything that publishes to customers, anything that touches the goal set. Those wait for the ruling. **A gate surfaced without a recommendation is an incomplete forward, not an exempt one.** The grant runs only on a stated recommendation. So an item raised as a bare choice ("Todo or Park — one line settles it") can never fold: it waits indefinitely while reading as handed up. It is not carried as it stands. The next loop finishes the assessment, resolving any premise it can check for itself, and re-surfaces the gate in the decision-item format with its recommendation (`convention-comms-owner`). The five days run from that re-surfacing. (Worked case: A1-351 was surfaced on 2026-09-14 as "Todo or Park" with no recommendation. It then sat seven more days as the only blocker behind the vertical's off-track driver, although its one open premise was a single download away and the Owner's 2026-09-11 stand-up ruling already authorised the move — APP-1569, 2026-09-21.) **Read the thread before folding — a standing ruling beats a default.** The grant is for a gate the Owner has *not* ruled, so "unruled" is a claim about the thread and is checked against it: the ticket's own comments first, then the decision log — and note the asymmetry there, since a ruling captured only as a comment is *not yet recorded* (`convention-decision-log`), which makes it unlogged, never absent. A default folded on top of a ruling the Owner has already given on the same question in the same thread is not a folded default at all; it is an overwrite, and it is the more expensive failure, because the ticket then carries criteria that contradict his own instruction while reading as agreed. So where the thread carries a ruling on the question, the ruling **is** the answer: apply it, cite it, and where it supersedes what the ticket already says, reconcile the criteria to it rather than adding a second direction alongside. Where the thread carries a ruling on a *neighbouring* question and this gate is genuinely open, the fold says which is which. (Worked case: MBN-263 — the Owner directed on 2026-08-10, in a comment on that ticket, that QuickBooks was already in use and the ticket should be re-scoped to wiring Shopify revenue into it; on 2026-08-22 a routing comment folded the opposite default, "spreadsheet now, QuickBooks later", into the acceptance criteria and cited Pattern A folded validation as its authority. Twelve days, one thread, two directions, and the citation was doubly wrong — Pattern A is the embedded-criteria discipline, and this grant is what extends folding to Owner gates — APP-1357.)
   - **Criterion waivers on evidence.** The operator may strike an acceptance criterion with a recorded one-line waiver where it holds evidence the criterion was mis-written (`convention-ticket`, *Waiving a box*), rather than routing it to the Owner.
   - **How and where, inside a ruled what.** Where the Owner has ruled the direction and a note or ticket in this vertical asks only where a rule lives, what shape it ships in, in what order, thin or full, fail or caveat, or which mechanism to use where canon already leans, the operator rules it — on the ticket, as an `[operator-<venture>]` ruling with a citation of the what it sits inside — and reports it under *Decided*; it does not ask. The *what* — direction, a mandate change, money, security posture, credentials or an external account, a config lever, a ruling's provenance, or anything genuinely two-sided — still goes up (Owner decision, Aled 2026-09-03, APP-1099; the Pulse-queue twin is `skill-ops-retro` step 5).
   - **Assessment before escalation — the Owner gets the calls, not the material.** Where anything needs the Owner's decision or sign-off, **the operator does the full assessment first** and brings him only the judgement calls that are genuinely his, each carrying a recommendation; he does not read and assess the underlying material. This is **not** scoped to legal or policy documents — it covers content and copy, design and build sign-offs, reviews, supplier and tool choices, scope and trade-off calls, and anything else routed to him; legal pages were only the first instance (Owner ruling, Aled, 2026-09-11, BARA session — in his words, a CEO does not review every word of a policy but makes the judgement calls where it matters; APP-1352). It applies to all five operators. The shape is three steps. **(a) Operator review** — the operator, or the functional agent it commissions, reads the whole artefact against its sources: how the business actually runs, the live store or surface, prior decisions, the relevant canon, and the legal baseline where one applies. It is a competent sense-check, it does not stand in for professional advice, and it says so wherever that distinction carries consequence. **(b) Exceptions brief** — the Owner receives one line per judgement call, each with a recommendation (*"returns window: the draft says 30 days, the store setting says 21 — recommend 30"*), closing with a line naming everything else that was checked and found fine (`convention-comms-owner`, *The sign-off brief*). **(c) Owner sign-off** — he rules the exceptions and signs off the whole; the sign-off itself, and any binding or public act (publishing, accepting terms, spending), stays with him and is **not** foldable under the aged-gate grant above. This does not widen what the operator may *decide* — a human-faculties or authority question still goes up, by the same forward format — it changes only what travels with it: a distilled call instead of raw material. A review-heavy sign-off ticket is therefore **split** into an operator-review leaf (`operator-<venture>`) and a short `human` sign-off leaf, the same shape step 3(b) above and `convention-secrets` set for credential-gated work. (Worked case: MBN-279 / MBN-280, six policy and trust pages — privacy, terms, returns, shipping, contact, cookies — sat in the `human` lane waiting for the Owner to read and assess all six. Reviewed under MBN-283 by `operator-bara`, closed the same day, one sign-off ask landing on MBN-280 — APP-1352.)
   - **A standing unattended mode, run to an end-of-day target.** The grants above each settle one question at a time; none of them describes a *mode*, so an operator holding every one of them still has no written warrant to keep going when the Owner is not there. It may be placed in one: a **standing unattended mode** in which it runs to a stated end-of-day target, rules the reversible work inside its mandate itself, and **tickets what it cannot rule rather than pausing**. This is a transcription of the Owner's own instruction, given verbatim on 2026-10-21 and applied the same day as D149 and D150, not a new direction — in his words, *"I want /operator-a1 to manage the agents required and to make decisions so that we have a completed set by the end of the day. Try not to pause for me on much. If anything is worrying you we can capture and raise tickets to review in the morning."* Four mechanics, all of them inside the positive grant above and none widening it. **(a)** Where the operator holds a **strong recommendation** on a reversible, rote question, it rules and records; it escalates only where the call is critical and genuinely needs a human review. **(b)** Anything that worries it becomes a **`REVIEW:` ticket carrying `human`**, raised for the next morning, and the run carries on around it — the ticket is the pause, so the session is not. **(c)** An **irreversible, public or credential-gated** item, or one that would contradict a ruling the Owner has already given, is ticketed and skipped by the same forward format the grant already sets. **(d)** The gate items the run does raise are **batched into one end-of-day status**, worst consequence first, rather than sent as they arise. The mode changes who waits, never what may be decided: the three anchors stand, the human-faculties and authority categories still go up, and every ruling still carries its citation. The grant itself is stated once, in `core-operating-model` (*Operators, and the tiering*); this is the procedure under it. (Worked case, **reported**: the 2026-10-21 `operator-a1` session on `a1.MeirionPritchard` was given this mandate in the words above and logged it as D149 and D150, with no artefact describing the mode it had just been put into — APP-2563.)
   - **And a name not yet shipped to a CMS schema is reversible.** Reversibility is the load-bearing test, so what counts as reversible decides how much of the mode above is usable — and a value that *will* become a schema enum reads as irreversible to an operator applying the test literally, although nothing has shipped and nothing yet depends on the word. It is not irreversible. **A name is reversible until the schema carrying it is deployed and live content references it**; the deploy is the irreversible act, not the choice of word, which is the same cut the grant already makes between a reversible move and one that cannot be unwound. (Worked case, **reported**: on 2026-10-21 the operator held A1-495 — the name of a caption block's third size — for the Owner on the ground that the value becomes a Sanity enum. The Owner ruled "one-third" and said the operator could have made that call, recorded as D167, so the hold cost a round trip the grant had already covered — APP-2563.)
   One grant was put and declined: milestone target dates stay the Owner's (`convention-project-status`). Everything else proceeds.
6. **Proceed autonomously.** Unflagged work goes ahead within the vertical (the operator is the gate); unflagged ready work is promoted for the fleet to execute. This mirrors the delivery loop's selective gating, one tier up — the operator does not approve its own merges; Prism's review gate and the delivery-loop merge gate still stand.
* **Promotion tests shape as well as readiness — the Pattern A heading check, before the write (**APP-1327). "Unflagged ready work is promoted" answers *should this proceed*; it does not answer *is this ticket buildable*, and those are two questions. Before promoting any ticket to **Todo** under a delivery executor, re-read its description and confirm `## Acceptance criteria` **and** `## Definition of done` are literally present as `##` headings with checkbox lists beneath — the same claim-time check `skill-triage` makes at routing and `skill-build-ticket` step 3b enforces at the claim. This is a **heading-presence check only**, never a judgement on the criteria themselves: the loop is not re-refining the ticket, it is refusing to hand a malformed one to a builder. A ticket missing either heading is **not promoted** — leave it where it is, route it back to `agent:R3-LAY` for the missing section, and name it in the run's *Decided* line with what is missing. Treat a batch promoted in one act as **one population**: where one member fails the check, check every member rather than only the one that surfaced. The cost of skipping it is not a caught error but a spent Forge cycle — `skill-build-ticket` step 3b bounces the ticket correctly, at the most expensive point, and evicts it back to Backlog, and the operator learns a day later by reading Backlog state rather than from the promotion step. (Worked case: the 2026-09-10 `task-apps-operator-standup` run promoted five Luna Phase 0 tickets — APP-60/61/62/63/64 — from Refinement to Todo on the folded default, reasoning only about the recommendation's age and reversibility; APP-62 and APP-64 round-tripped Todo → In Progress → Backlog inside two minutes on Forge's format gate for a missing `## Definition of done`, and the other three were never checked — APP-1327.)
* **And promoting is the operator's default, not routing to the triage lane (**APP-2361). The check above says what a promotion must confirm; it does not say when promoting is the right move at all, and an operator reading step 4's dispatch grant beside it can conclude that anything it did not refine itself belongs in a queue. It does not. On a leaf that is **refined, unblocked, heading-complete and in its own vertical**, the operator's default is to **promote it to Todo under the delivery executor** — the mandate's autonomy lever (`core-operating-model`, *The mandate*: every tactical and day-to-day choice is the operator's), expressed as the promotion grant this step already holds, with the Pattern A heading check above as its precondition. `agent:R3-LAY` is **reserved for what the operator cannot promote**: a non-leaf parent, an unrefined or blocked leaf, or work needing a connector-fleet executor rather than a delivery one. Routing a promotable leaf there is not the safer choice but the slower one, because that lane is **rate-capped rather than unread** — `skill-triage` bounds its pass at *at most five rows per delivery team per fire*, so a lane receiving more than five a run per team is working exactly as written while its oldest rows age past anything the ladder can express, and a second triage cadence buys a week where a promotion costs a write. (Worked case, **observed** this run: `list_issues(team: "Apps", label: "R3-LAY", state: "backlog")` returned **57 rows**, `hasNextPage` false, every row in a state named `Backlog`; **55 in portfolio** after the two standing exceptions APP-1303 and APP-750, against 56 reported on 2026-10-14 and again on 2026-10-21 — eight days, a net one. The oldest is still APP-514, created 2026-05-22, **153 days**. And the lane *is* being read: no Urgent row remains in it, APP-2138 and APP-2140 have left and APP-2248 and APP-2249 were promoted, while the Highs APP-2159, APP-2160 and APP-1570 are still sitting there. A lane that drains at that rate is capped, not silent — APP-2361.)
7. **Report status, in the standing operator format.** Report against the vertical's declared **State sources** — the dashboard artefact where one is named, otherwise the board scope — the same surface read in step 1 — and write the cycle's status as the vertical's **native project / initiative health update** (`convention-project-status`), in the operator standing-report format (`convention-comms-owner`, *The operator standing report and Owner-session agenda*) — **Status** (with a RAG flag) → **Decisions pending** → **Decided** → **Forward** — and set the native `health` flag each run. Every line under *Forward* takes one of the three shapes `convention-comms-owner` fixes — a dispatched move citing a ticket that exists, an observation marked as ownerless, or an item marked as awaiting a named Owner ruling — and a Forward line proposing an action is written only after step 4 has filed the ticket or recorded why it did not: the gate is step 4, not this step. (Worked case: the A1 cutover chain A1-267 → A1-268 → A1-34 was "worth sizing into a hold window with Aide" in two consecutive updates and moved only when A1-362 was filed — APP-999.) A flag carried into a second consecutive report converts: it becomes an action the operator takes, or an escalation with a recommendation — never a third mention (MBN-264's routing observation was "flagged for Relay, not acted on" across three loops before anyone moved — APP-1064). **Before writing, read the vertical's own last status update on that surface: if one already falls inside the current cadence window — a second run at the same altitude in the same window — emit the *delta* since it and skip re-posting the standing report, and write the `health` flag *deliberately* (re-affirmed only where still true) rather than as an unconditional per-run stamp (APP-884).** **That predecessor read is made at `limit: 1`, never as a window** — one row carries the date, health and open items the test needs, and a six-row read of an initiative's update history overflowed the response in a single call, so the lower limit is the test's cost rather than a recovery from it; the endpoint's overflow behaviour and its recovery path are `convention-linear`'s *Reading Linear safely* bullet on `get_status_updates`, whose per-project `limit: 1–2` default is written for the cross-venture health read and not for this one, which is why step 7 must bind its own (`APP-3036`).

   **And an unexpectedly old predecessor is itself a finding.** That read exists to prevent a duplicate inside one cadence window; it says nothing about the opposite result. Where the vertical's last status update on that surface predates the current window by **more than one window**, the run **names the gap in the report it writes** — the surface, the date of the last update, and the number of cadence windows missed — rather than writing the next one as though the record were continuous. Two adjacent readings are part of the same check. A surface that has **never** carried an operator-format headline is reported as never having carried one, not as merely stale: an existence check keyed on the artefact passes either way, and the two have different remedies. And a **daily**-altitude update sitting on an initiative is itself a defect signal rather than a miss — it means mirror behaviour is still running somewhere, or a daily routine is mis-targeted, and it makes the surface read as non-empty to any existence check. This is the weekly twin of the daily stand-up's rule (d) under *The emit surface*, and it is free for the same reason: the read is already mandated, so the check costs nothing beyond stating what was read. A missing weekly report looks like nothing, because the dailies keep producing — the tactical altitude carries signal while the strategic altitude is silent — so unless the run that finally fires says so, three missed cycles read as three ordinary weeks. (Worked case: `task-mrp-operator-loop` did not run on 29 August, 5 September or 12 September 2026; the 14 September run read a 22 August predecessor and had no rule telling it to report that. `mrp.owner-session-agenda` went three weeks without a refresh and still listed two items the Owner ruled on 1 September; the charter's capture-ahead-of-writing objective inverted unreported. The same 23-day gap was confirmed the same day on BARA and on bot.Trader, where a 09-12 daily brief flagged a mandate green while its entire critical path was stopped, and on Apps, where the weekly loop had not run for 23 days — APP-1433, APP-1431, APP-1428.)

   Report at the altitude the Owner fixed on 2026-09-02 (APP-998): **projects carry the daily signal; initiatives carry the operator's weekly headline.** `task-daily-report` writes one short status update per live project each morning with an explicit `health`; the operator reads those and writes the week's headline — Status with its RAG flag, Decisions pending, Decided, Forward — as a status update on the vertical's own initiative (BARA relaunch, A1, Apps, Mr Pritchard, bot.Trader). The "team-mirror initiative" is retired as a concept: the daily brief no longer needs an initiative, so a vertical whose only whole-vertical initiative once doubled as the mirror simply owns it (A1, Mr Pritchard — APP-888, APP-998, APP-1002). Where a vertical reports per mandate or per bet, the per-project updates carry that split and the initiative carries the cross-cutting line; a portfolio operator reports its allocation on its own initiative. Never post the weekly altitude into a project's daily stream (APP-867). Surface upcoming plans and objectives for the Owner's light review before the next cycle acts on them.
8. **Prepare the Owner session (weekly).** Maintain the **standing Owner-session agenda document** — one per vertical, named `<vertical>.owner-session-agenda` on the vertical's initiative, found by name before anything is written and refreshed rather than rebuilt (`convention-comms-owner` holds the name, the lookup step and the carry-forward rule). It holds only *open* items — the mandate-edge escalations awaiting a ruling and the upcoming plans needing light review, each in the decision-item format (**decision · recommendation · why it matters · risk of deciding vs not**) — in the two sections the convention fixes, *Open — decisions for the session* and *Async — not for the session*. A ruled item moves to the decision log and drops off. **And an item that went to a session and came back unruled is reported as that, not re-listed as an ordinary open item.** Where an item's named session date has passed and it carries no ruling and no comment, the refresh says so explicitly — *"session was confirmed for the 25th; this item shows no evidence it was addressed"* — and does not guess between the three readings it cannot tell apart from this surface: the session did not happen, it happened and did not reach this item, or it happened and the ruling was never written back. A calendar confirmation is evidence a slot exists, not evidence a decision was taken; and since the session is never released and runs its full time (APP-852, APP-1657), an unruled item after one is information rather than noise. It costs one comparison on a read the refresh is already making. (Worked case: `bara.owner-session-agenda`, refreshed 2026-09-25, stated the Friday work.Operators session "confirmed on the calendar this run" with MBN-321 — Urgent, goal-set anchor — as item 1. The following Monday MBN-321 carried no comment beyond its creation, no ruling, still Todo, and nothing in the loop was obliged to notice — APP-1809.) A carried item is **re-grounded, not re-listed**: on its second week its premise is re-checked once against the live artefact it rests on, so the agenda never asks the Owner to rule on a state that has already dissolved (MBN-250's "hide the three bundles" item carried for a week after every bundle was found to be draft — APP-994). **And where a carried item's premise is an event outside the tracker, the re-grounding read is of the calendar occurrence, not only of the thread (`APP-3146`).** The re-check above resolves "the live artefact it rests on" to the ticket; for an item whose subject is a session, a call or a dispatch, the ticket is a hand-kept copy and the occurrence is the artefact. The discriminator is the one `convention-linear` already fixes off the title's own verb (`APP-2407`), so nothing new is read to decide it. On such an item's second week the refresh therefore issues one calendar read for the event the ticket names, on the connector the loop already holds, and **states which call it made and what it returned, nil included** — the reporting discipline `APP-3126` sets for the rota read, applied here. The `blocks`-edge extension above cannot reach this fact: an invitee's acceptance writes to no thread, so no ticket the item blocks can carry it. Two limits hold the read. **An acceptance is evidence a slot exists, not evidence a decision was taken** — the clause earlier in this step says exactly that of a confirmation (`APP-2712`), and a richer read does not weaken it; and **nothing is re-dated off a calendar read**, so a later occurrence is reported and never written back onto the item's due date. The read is of the event the ticket names rather than of a remembered occurrence, because the premise can move onto a **different recurring series** from the one the earlier declines sat on, and a query pinned to the slot last seen can return a true answer about the wrong series. (Worked case, **observed** at the read that authored this clause: `A1-696` — `SESSION: 30-minute run-through and forward-looking chat with Ann`, Todo, Urgent, due 2026-10-14, `blocks [A1-543]` — was carried five cycles on five declined recurrences at 14:00 under recurring id `64j70ocu48t571dalv01l98efr`, while the invitee had accepted a newer 16:00 series, `f6f9t2k0u5np0phnk1d0vg44pu`, `updated` 2026-11-17T11:57:13Z and accepted forward across 2026-11-24 and 2026-12-01 as well. The unattended fire twenty minutes later caught the acceptance only because step 8's single obliged calendar read happened to go out as a seven-day `list_events` rather than the single-occurrence query the rule as written permits. One instance.) **And a new item is grounded before it is listed, in its first week as well as its second.** Before any item enters *Open*, the refresh reads the ticket it cites (its description and its comments) and the decision log for a ruling on the same question, because the second-week re-check above catches a premise that has dissolved, not a question that has already been answered. **And where an item's ticket carries `blocks` edges, the grounding read extends to the threads of the tickets it blocks.** A gate carries `blocks` edges precisely because it is holding work, so a ruling that *dissolves* the gate most naturally lands on the thing being gated — the Owner is working there and answers there — and an unread dissolving ruling costs twice: it keeps a resolved item on his agenda **and** leaves its dependents formally blocked. So for an item entering *Open*, and for a decision-pending note, the first-week grounding and the carried-item re-grounding both read the blocked tickets' comments as well as the cited ticket's own. **Scope is gating items only** — the items carrying `blocks` edges — because reading every related ticket's thread is a different and much more expensive rule; the relations are already fetched with the ticket, so the marginal cost is the read and not the lookup. This is the *where* of what `APP-2537` already fixes — an Owner ruling newer than the last field change is a finding the reading surface must enact or route — and it belongs in this step rather than step 5's thread-reading guard because step 8 is the act that grounds an agenda item while step 5 governs folding a default (`APP-3048`). (Worked case, **observed** at the read that authored this clause: `APP-2728` is Done, `completedAt` 2026-11-11T12:25:07.028Z, and its `blocks` set is `APP-2248`, `APP-2249` and `APP-2580` — the edges this rule keys on. The Owner's ruling is quoted back on `APP-2728`'s own thread at 2026-11-11T12:25:04Z, which supersedes the filing note's line that the thread carried nothing after 2026-11-08; the gap the note describes is unaffected. One instance.) Where a ruling exists, the item does not go on the agenda. It is applied and reported under *Decided*, citing the ruling, which is the same test step 5 sets before a folded default (*Read the thread before folding*). (Worked case: the 2026-09-14 Apps agenda asked the Owner again to graduate os.Claude, ruled on APP-1168 on 2026-09-08. It also asked for os.Claude KPI baselines, which APP-756 had delivered, Done on 2026-09-07, and for keroma and bot.Trader membership, ruled on APP-882 and APP-995 on 2026-09-11. That was four asks, each already answered on the ticket it cited — APP-1571, 2026-09-21.) The agenda is **initiative-level only** — strategy, goals, resources, targets — never tactical. Size it and hand it to **Aide** to book into the `work.Operators` window (`convention-hold-windows`). **The session is never released, and it runs its full allocated time.** It is 30 minutes — the length of the window — whatever the agenda holds. An operator with nothing to raise **still uses the whole slot**: it carries the status report and the Owner's own input, because he always has items from his side the operator cannot see, and he wants a status report weekly whether or not anything is wrong (Owner ruling, 2026-08-17, APP-852). The **reduce path is retired**. There is no 10-minute floor and no confirm-or-reduce call, taken at loop time or on the morning of the session or anywhere else, because the loop now runs about **an hour before the session on the same day**, so anything arriving overnight is already in the agenda the loop produced (Owner ruling, Aled, 2026-09-22, APP-1657). The operator prepares and attends; Aide is the single calendar writer, so the operator never books the window directly.

**And the pass measures the *rate*, not only the item — a sitting that ruled nothing is a finding in its own right.** The guard above fires **per item**, so an agenda carrying eight unruled items produces eight per-item remarks and no statement at all about the sitting that produced them, and a **wholly** unruled agenda clears every check this step carries: each item is correctly reported as unruled, nothing is obliged to notice that the sitting's ruled-to-raised rate was zero, and N per-item flags on one agenda read on the board as N small misses where one rate reads as the sitting not having happened. So the refresh **measures and reports the ruled-to-raised rate for the sitting itself** — rulings landed over items raised, stated as the pair of counts and never as a bare proportion — alongside the per-item lines, and a sitting returning **zero rulings from an occupiable session** is a reported finding in its own right, carrying the count and the session's own date, raised as that rather than folded into the item list. The asymmetry is what earns the rule: a per-item flag is actionable by re-listing the item, which is exactly the wrong action where the sitting is what failed, and the rate is the only figure that tells the two apart. The read is cheap because both halves already exist — occupiability is tested before the agenda is prepared (above), and the refresh already holds the item set it is reporting over, so the rate is a division over figures in hand and not a new read. (Worked case, **reported**: a Mr Pritchard item has sat unruled across **five** consecutive weekly sittings, each refresh correctly naming it as an item that went to a session and came back unruled, and no refresh stating that the Monday sitting's ruled-to-raised rate had been zero for five weeks running — five per-item reports where one rate would have read as the session not having happened. `APP-2810`.)

**Before the agenda is prepared, the loop reads its own vertical's `work.Operators` occurrence for the rota day and tests that it is occupiable.** Occupiable means **present on the calendar and not overlapped by an all-day leave or out-of-office event** — `convention-hold-windows`' *Unavailable by absence* rule, which already calls an overlapped hold **zero capacity**. It is one calendar read, on a day the loop is already reading for capacity. Where there is no occupiable occurrence, the agenda is **written as an async hand-off rather than for a sitting**: its opening line states the absence and names its disposition — async rulings requested on the named tickets, or a request to Aide for the next available occurrence — and the absence is **reported as a finding, on the same footing as the missed-refresh guard above** (`APP-1536`). The finding is keyed on **no occupiable occurrence on this vertical's own rota day**, which is a different fact from a weekday with no occurrence: `convention-hold-windows` rules that a weekday without an occurrence is the `work.Operators` rotation working as the Owner declared it (`APP-2042`), and that ruling stands untouched — what this tests is the rota day the loop itself fired on, where an occurrence is expected because the rota expects it. **Why it is quiet, and why no existing guard catches it:** step 7's unexpectedly-old-predecessor check and step 8's own missed-refresh guard both pass cleanly, because being current is exactly what lets it through. Nothing in the record distinguishes *agenda prepared and ruled* from *agenda prepared and never read*, so the next refresh re-grounds the same items and reports them unruled-after-a-session — the correct report and the wrong diagnosis. The cost is one week per occurrence, charged on the items that by construction cannot fold: the mandate-edge escalations only the Owner can clear. (Worked case, **reported** by `task-a1-operator-loop` from reads at 2026-10-20 11:2xZ and **not re-read from a canon drain's surface**, which reaches no calendar: the loop fired 2026-10-20 12:15 local on A1's rota day and there was **no `work.Operators` occurrence on it**. The day held `work.Standup` 09:00–09:30, `Aled <> Hal` 10:30–11:30, `Birthday — out of office` 12:00–18:00, created 2026-10-19 08:49Z on `a1.cycle-goal.2026-W43`'s own instruction, and `personal.Lunch`. The loop produced a full agenda carrying three authority-category items and handled the absence by hand — stating it in the agenda, routing to async, and setting the A1 initiative status `offTrack` naming it — which is the right disposition and is now the written one. A1-571, a goal-set change excluded from the aged-gate grant, has been through two named sessions unruled and is 20 days overdue. `APP-2489`.)  **And the test is keyed on the series, not on the day: before any occurrence is read it reads `work.Operators`' recurrence definition and the set of weekdays that definition generates, and sets the rota against that set.** The rule above is scoped **per run and per day** — its finding is *no occupiable occurrence on this vertical's own rota day* — so a rota that names a weekday the series never generates fails it once a week in each affected vertical and reports as that many unrelated scheduling accidents. The arithmetic is why it stayed quiet: five verticals hold one rota day each and the series generates three weekdays, so two verticals are **structurally** unservable, and each of their runs reports a single absence that is locally true and causally wrong — Apps took three weeks to name it and A1 one week (**reported**). So the loop **reads the series rather than the day's occurrence** first: the recurrence rule and the weekdays it yields, which this file's weekly-cadence entry already records as **observed** and `convention-hold-windows` holds as the single holder of the window's cadence — both cited here, neither restated — and it compares the five rota days against that set. Where the two do not match, the finding is **one structural finding naming every affected weekday and vertical at once** — *the rota names N weekdays the series does not generate, each with the vertical it strands* — raised **once** and never re-raised per run: an affected run's agenda still goes async by the rule above, but its opening line states the structural finding **by reference** instead of reporting a fresh absence, because N independent absences is exactly the report that cost three weeks. The remedy is **neither authored nor filed from this loop**: making the rota servable is a **calendar config action for the Owner** — `work.Operators` gains the two missing weekdays, or the rota moves onto the weekdays the series already generates — and **Aide is the sole writer of that calendar**, so the loop names the action and writes nothing to it. The Owner question is **already surfaced** on `APP-2538` (`Blocked`, `Urgent`, decision-pending; the live recurrence rule re-tested this run and confirmed unchanged by a clearance worker — **observed**), so a run meeting this mismatch cites that note and does **not** raise a second Owner ask. What this rule changes is only the report: while the Owner decides, the loop stops presenting a structural rota-versus-recurrence mismatch as a run of per-day accidents — `APP-2867`.
**And where the occurrence cannot be read at all, the run names the call it tried and what came back — a capability absence is tested in the run that claims it, never inherited from a previous refresh's prose.** The rule above governs an occurrence that is absent or overlapped; it says nothing about a run that never performed the read, and that is the gap a surface falls through with its honesty intact. *"Not readable from this surface"* reads as a shortfall properly declared, so nothing downstream has cause to challenge it, and the line is then carried forward by every refresh that inherits the document — one claim surviving refresh after refresh on a premise no run tested. So a refresh that produces no occurrence states **which call it made and what the call returned**, and a claim that the capability itself is missing is **verified by attempting the read it names** in that same run; absent that attempt the agenda reports the test as **not performed**, which is a finding, rather than as impossible, which is an assertion about the surface. Whether a connector was ever absent is beside the point: connector attachment is a property of the session rather than of the vertical, so the claim has to be re-derived where it is made. This is the tool-availability form of the premise discipline `task-bottrader-daily-report` already carries for a repo read — *whether a repo is readable is a property of the session rather than of this surface* — cited here and not restated, and it is the mirror of `APP-1809`, where an agenda asserted a session was confirmed without evidence: there a surface claimed more than it had read, here it claimed less. Nothing here moves the write: Aide remains the sole calendar writer (`convention-hold-windows`), and reading an occurrence is this step's own instruction. (Worked case, **observed** from this drain's own cloud surface on 2026-11-17: `mcp__Google_Calendar__list_calendars` returns the Owner's two calendars, and one `work.Operators` search returns the live recurring series — the 2026-11-16 occurrence 13:30–14:00 Europe/London, `confirmed`, `AVAILABILITY_FREE`, recurring id `26mvgv08778cdsgllkok605gsa`, with further occurrences on 19 and 20 November. The Mr Pritchard weekly loop made the same read at about 12:2xZ on 2026-11-16, 1h13m before its own 13:30 sitting, after four consecutive refreshes of `mrp.owner-session-agenda` and two Mr Pritchard initiative status updates had carried *"this leg runs on Cowork / Linear with no Calendar connector"* — those refreshes and updates are **reported** and are not read from this surface. Whether the sibling operator loops and standups carry the same line is **not checked** by this change, which binds the claim and not the vertical. `APP-3126`.)

   **And an agenda that has missed a refresh is re-grounded whole, not item by item (APP-1536).** The second-week re-grounding above assumes the agenda is refreshed every loop; it says nothing about an agenda no loop has touched. So the refresh first reads when the agenda was last refreshed — the document's own stated refresh date, the same lower bound `convention-comms-owner`'s inbound scan uses. Where that predates the current weekly window by **more than one window**, the refresh **names the gap at the top of the agenda** — the date of the last refresh and the number of weekly windows missed — and **re-grounds every open item** against the live artefact it rests on, not only those in their second week: an item carried through missed loops has skipped its re-check, and an item ruled in the meantime has skipped its move to the decision log. An agenda never refreshed since it was created is reported as **never refreshed**, not as merely stale. This is the agenda's twin of step 7's *unexpectedly old predecessor* rule, whose worked case already records the `mrp.owner-session-agenda` instance, and it costs nothing beyond stating what the lookup read. (Worked case: `bara.owner-session-agenda` was last refreshed 2026-08-22 and missed the 29 August, 5 September and 12 September loops; on 18 September all four open items were dead — one superseded by MBN-284, MBN-262 ruled and cancelled on 12 September, the milestones ruled on 1 September, the initiative grouping done — while its funnel line read 172 sessions and one cart against a live 302 and three, and it counted "12 weeks to 2026-11-14" towards a target since moved to 2027-02-26. The 27-day gap was also reported by the `[bara-standup]` comment on APP-1528 — APP-1536.)

Then the loop repeats on its cadence.

## The two cadences — tactical daily, strategic weekly (APP-852)

The loop runs at two altitudes, managing down daily and up weekly:

- **Daily — a shadow stand-up (managing down).** Before Aled's 09:00–09:30 stand-up, the operator runs a light pass of steps 1–6 over the previous *working* day in its vertical: what moved, what is stuck, what needs unblocking or input, and what new requirements to raise — a requirement the daily pass raises is filed to **Backlog with `agent:R3-LAY`**, correctly projected and labelled, and the fleet triages and breaks it down from there; **the raiser then carries it as an open item on every subsequent daily pass until it leaves Backlog**, escalating by age per `convention-linear`'s ladder once it is older than one triage cycle. **The carry set is re-derived by a query each pass, never inherited from the previous entry's prose.** Each daily pass is a fresh session with no memory of the last one, so "carries it as an open item" has to name a read or it names a recollection — and the read recipe below deliberately reads **Blocked, In Review, Todo and In Progress**, which does not include the bucket this duty is about. An item that falls out of the entry chain once therefore has nothing to bring it back, and the failure is silent in both directions: the item is on the board the whole time, and the entry looks complete because nothing is missing from it that anyone can see. So the pass adds one read to the recipe for this purpose only: **the vertical's projects, every backlog-type state, carrying `agent:R3-LAY`** — the routed-but-unclaimed shape — and carries every result, oldest first, escalating by age per the ladder above. **The bucket is the `statusType`, not the state literally named `Backlog`.** A team can run two backlog-type states, and an item given a first triage touch moves into the second one while staying exactly as unrouted as it was: Mr Pritchard runs `Backlog` **and** `Defined`, the engineering teams run `Backlog` and `Refinement` (`convention-linear`, the editorial state mapping). A read scoped to the literal name therefore recreates this duty's own blind spot for every capture that has been refined but not routed — which on the editorial team is the normal intermediate state, not an edge case, since its Backlog poll parks captures there for harvest pending a shape decision. `convention-linear` also records that `list_issues`' `state` param matches on the underlying `statusType` rather than on the literal name, so a connector call scoped by `team` already returns both states and the trap is in post-filtering the result by the state's name, never in the query; the rule is written over the bucket so that it does not depend on that behaviour holding. (Worked case: the 2026-10-01 and 2026-10-02 `mrp.standup` entries carried MRP-57 and MRP-58, both in literal `Backlog`, and carried none of MRP-59, MRP-62 and MRP-63, all three in `Defined` — MRP-59 created 2026-09-28 and carrying `operator-mrp` and `agent:R3-LAY` from that day, so three days passed before the 2026-10-05 run's read happened to cover both states and caught it. Re-read 2026-10-06: all three are still `Defined`, `statusType` `backlog`, carrying `R3-LAY`, moved out of `Backlog` by a triage poll on 2026-10-04 that deliberately kept the executor. Same silent shape as MRP-51's fifteen unresurfaced days in APP-1669, reached by a different route — APP-2033.) Derive it from the tracker, not from yesterday's write-up; the previous entry is a record of what was reported, never the list of what is open. (Worked case: `mrp.standup` routed MRP-51 to `agent:R3-LAY` on 2026-09-09 and it appeared in **none** of the fourteen subsequent working-day entries, surfacing only on a 2026-09-23 re-read as a fifteen-day-old untriaged Backlog item with zero comments. MRP-55, created 2026-09-21 in the identical shape, **was** carried correctly on 22 and 23 September — so the duty fires when the item is still fresh in the entry chain and stops when it is not, which is the signature of a remembered set rather than a derived one. Whether the same gap has occurred on the other four operator stand-ups is **not verified**; this rule is written so it does not depend on that. Same family as APP-982's five untouched days, cited above, and distinct from the Relay-side triage-latency root in APP-1012 and APP-1581 — APP-1669.) The operator cannot triage its own request, but it is the only party guaranteed to look again tomorrow, so a raise a poll misses once is not thereby lost. (Worked case: APP-982, the bot.Trader host-lane runbook, raised by the 2026-08-17 stand-up at 08:37 and untouched by anything for five days while four Urgent/High items accrued behind it — APP-1012.) It is tactical and fast. It writes no strategy and books no Owner time; it takes **no calendar act at all**: the operator session for that day is already booked and now runs its full allocated time, so there is nothing to confirm and nothing to reduce (step 8, APP-1657), and it may never book or prepare one.

  **The read recipe** — the five loaders inherit this rather than improvising it (APP-1011). *What is stuck* is read from **unbounded state buckets** — Blocked, In Review, Todo, In Progress — with no time filter, because an activity window inverts the staleness signal: the longer an item has been stuck, the less likely a `-P1D` read is to show it (the Apps stand-up of 2026-08-18 saw 14 Blocked through a two-day window against 31 in the bucket, all Urgent). The **operator-routed Blocked queue** — items the delivery lane has handed to the operator for a judgement (`convention-linear`, *Executor*; APP-1035) — is this bucket's first read and the stand-up's primary input: is the blocker real, should scope bend, is a third attempt worth it. Read it by the vertical's own **`operator` label, workspace-wide** — since 2026-09-03 that label is its own group, independent of the executor `agent` group and read with or without one, so a project-scoped read misses an item filed elsewhere that names this vertical as owner (an os.Claude canon note carrying `operator-a1`, for instance): query the bare value (`operator-bara`) across the workspace, then bucket by project. **Both reads are only as real as the label's stock, so backfill it once before trusting either.** The label is set at refine (APP-1217), which fixes the flow and not the stock: a ticket refined before that rule existed carries no `operator-<venture>` and never will, because refine does not run again on a ticket already refined. So on the first loop after this rule lands — and on any vertical whose scope read looks thin — the operator sets `operator-<venture>` on the open tickets in the projects its own profile declares under *State sources*, resolving the mapping by project rather than by team. It is one bounded, mechanical, reversible pass: tracker hygiene inside the vertical and never an Owner item (see *Guardrails*), written as a full `labels` replace per ticket (`convention-linear`, *Labels*). **Its required scope is the states this recipe reads, not the whole stock.** The pass is done, and the label-gap caveat below lifts, once every open ticket in Blocked, In Review, Todo and In Progress carries the label, along with any Urgent or High Backlog item. Those are what the queue and scope reads act on. Backlog and Refinement stock, and projects on Hold, are labelled opportunistically, in bounded chunks across later loops, and are never a precondition. The reason is that the connector has no bulk label write and each `save_issue` returns the ticket's full description, so a large Backlog takes many loops of single-ticket writes. A loop that stops short of the required scope names what is left and resumes there on the next run. (Worked case: A1's first loop under this rule, on 2026-09-21, labelled 39 of about 134 open tickets: every Blocked, In Review, In Progress and Todo item plus two Urgent Backlog items. It left about 95 Backlog and Refinement tickets, about 40 of them in the Hold project `a1.Muse — Audit` — APP-1568.)

  **And completion is claimed only on a read that could have falsified it.** A label-scoped read (`list_issues(label: "operator-<venture>")`) returns only tickets that already carry the label, so it can never return one that is missing it and cannot test the sentence above in the direction that matters. A run may therefore declare the required-scope pass **complete** only on the strength of a **per-state, team-scoped board read** — Blocked, In Review, Todo, In Progress, and the Urgent/High rows of Backlog — naming the count it found in each state and that every row in it carried the label. Absent that read, the pass is reported as **advanced**, naming what it labelled and what it left, and the caveat below stays up. **And a completion claim names the rows it read, per state, not only how many there were.** The identifier-list rule this file already carries — *the identifiers behind a count are written with it* (`APP-2336`) — is written for a scope or queue count in a stand-up entry, and it is not applied to the verification read above, which is the one read the retirement of the caveat rests on: so the figure that most needs to be falsifiable is the one still written as bare prose. The per-state read therefore names, **for each state, the ticket identifiers in the set it covered**, not only the counts; and a claim that also **backfilled** rows names the **per-ticket write list and a read-back of each write**, never an aggregate read taken after the batch. The write-list half is not a new mechanism — `convention-linear` already requires a priority write be read back, and a label write is the same call with the same failure mode. Without both halves, a correct-looking per-state report and a row carrying no label are the same record, and the claim cannot be re-tested by anyone who did not run it. (Worked case: the 2026-10-21 Apps report retired the caveat in exactly the prescribed shape, **reported** as Blocked 62 rows / 0 unlabelled, In Review 12 / 0, Todo 34 / 0, In Progress 11 / 4 all out of portfolio, and backlog-type Urgent/High 35 / 4 all `bot.Trader-B`. The 2026-10-28 re-run of the same read **observed** 75 Blocked rows, of which 7 carried no `operator-*` value and **three sat inside the population the claim was made over** — `APP-2132`, created 2026-10-07, `APP-2514` at 2026-10-21T08:36Z and `APP-2517` at 2026-10-21T09:27Z, all three Blocked and Urgent then and now, and all three in place before the 2026-10-21 loop fired at 11:17Z. `APP-2132`'s labels were re-read with `get_issue` to rule out a truncated list response: `["task","PUL-5E","work:configuration"]`. The caveat was put back up and the seven rows backfilled. **Which of two things happened is an unverified premise and is named as one**: either the per-state read was narrower than it was reported to be, or the label writes on those rows returned success without landing. Both leave the same signature in the record, and distinguishing them needs the per-ticket write list that report did not keep, so neither is claimed — the split is **observed**, the cause is not. `convention-linear` carries an adjacent unverified flag for a `priority` write returning success without effect on another team (`APP-2270`), cited as adjacent and not as proof — `APP-2730`.) The cost is five cheap state-scoped queries on the one loop that claims completion, never on every loop. This is the opposite sign of the error the thin-scope rule below already guards: that one stops a run reading a label gap as a quiet vertical, this one stops it declaring the gap closed — the more damaging direction, because the claim **retires the caveat**, and every later run is then entitled to treat its label-scoped read as the whole vertical. (Worked case: the 2026-09-25 BARA weekly report declared the pass met under *Decided* — "the required-scope label pass for BARA is now complete: every ticket in Blocked, In Review, Todo and In Progress carries it, as does every Urgent/High Backlog item" — on a label-scoped read returning 40 rows. A per-state board read on 2026-10-02 found seven tickets inside required scope carrying no `operator-bara`: MBN-285, MBN-286, MBN-289 and MBN-294 in Todo, and MBN-251 (Urgent), MBN-278 and MBN-293 in Backlog — four of them the Stage 2 merchandising set the same report had discussed at length in its own *Forward* section. The backfill and the five-read verification were both done that day: 5 Blocked, 5 In Review, 1 In Progress, 10 Todo and 5 Urgent/High Backlog rows all carrying the label, agreeing with a workspace-wide label read of 46 rows — the agreement being the whole point, since the label-scoped read alone cannot produce it. The same reads also corrected a lane claim made without them: MBN-278 is Backlog carrying `R3-LAY`, not "In Progress, non-leaf parent" — APP-1977.)

  Until it is done, **a thin scope result is read as a label gap, not as a quiet vertical**: a scope read confined to a single project, or returning only tickets created after the label existed, is reported as suspected-incomplete with the projects it should have covered named, never handed up flat. (Worked case: on 2026-09-14 `list_issues(label: "operator-apps")` returned seven issues, `hasNextPage: false`, all created 2026-09-10 and all in `app.AgentArt`, every one carrying an executor — so the queue read returned zero and the scope read returned a small, plausible, entirely unrepresentative set, while os.Claude's blocked canon queue, Luna's build lane, careerOS's unrouted tickets and app.fitness's frozen path carried the label nowhere — APP-1429.) **Scope and queue are two different reads of that label** (Owner ruling, Aled 2026-09-04, APP-1117). **Scope** is every ticket carrying `operator-<venture>`, executor or not — what moved, what is in flight, what is blocked across the vertical. **Queue** is the subset carrying `operator-<venture>` **and no executor**: the judgements pending on the operator itself. **The operator-routed Blocked queue line is produced by the queue test, not by the scope test.** A ticket carrying an `agent`-group executor is inside the vertical's **scope** and is **not** inside its operator-routed Blocked queue: the queue is what is genuinely waiting on the operator or on the Owner for a judgement, and a line that lists executor-carrying tickets reports delivery work as pending judgement, inflating the one count the stand-up acts on. The line therefore names which test produced it. (Worked case, **reported**: four consecutive `a1.standup` entries listed executor-carrying tickets under an "Operator-routed Blocked queue" heading, the fourth in its 2026-11-11 08:50Z entry — `APP-2959`.) **A queue or scope count is written with the read that produced it.** **And the identifiers behind a count are written with it.** The entry records the identifier list the count was derived from — the ticket IDs themselves, not only the query that returned them, its scope and the time it ran — because the requirement that a moved count name which ticket entered or left is otherwise unsatisfiable by construction: a prose figure persists from entry to entry and a membership set does not, so the next run holds two numbers, has nothing to diff, and can only re-derive the whole set and guess at the difference. Both directions then fail silently. An under-count and a genuine state change read identically to anyone holding only the figures, and a ticket carried in the wrong bucket looks exactly like a ticket that has not moved. With the list in the entry the diff is direct, membership against membership, and the attribution the rule already demands becomes mechanical rather than reconstructed. (Worked case: a scope count moved from 23 to 44 across two consecutive entries with no attributable cause named, and a ticket was carried in the wrong bucket for two or more entries after it had already moved on — one miscount and one state mismatch, indistinguishable to a reader holding only the prose figures. A predecessor note closed *assessed, not warranted* on exactly this re-test condition, and this is the second instance inside that window, which is why one more observation now carries the rule — APP-2336.) The entry naming a count states the query, its scope and the time it ran, and where the count differs from the previous entry's it names which ticket entered or left. **And a delta the entry cannot attribute is named as its own finding in the pass that first fails to attribute it, never carried in prose until the repeated-observation trigger fires (APP-2674).** The rule above says to name which ticket entered or left; it is silent on the case where the attribution is attempted and comes up short, and that silence is load-bearing, because an unattributed delta is the one shape in this rule that **decays**. The identifier list this rule already requires is what makes the diff recoverable at all, so the window in which a moved count can still be reconciled is the window in which the prior entry's membership set is still to hand; once intervening entries have passed, the delta is unattributable in principle rather than merely unattributed, and no amount of later diligence recovers it. So an entry reporting a count whose movement it cannot fully account for states the **residue** — the unattributed portion, signed, with the window it spans — and converts it in that pass, into a ticket or into an escalation carrying a recommendation, rather than restating it. **Partial attribution is reported as partial, with the residue as the finding and not the footnote**: `+4, 2 attributable to newly-created tickets, 2 unattributed, on top of an open -7 from 2026-10-21 to 2026-10-22` is the honest form, and the second clause is the one that earns the conversion. Step 3's repeated-observation rule still applies and is deliberately not the first line of defence here: it fires on the third consecutive mention, by which point the membership evidence that would have settled the first delta has aged out, so a count delta that reaches it is a late catch rather than a timely one. (Worked case, **reported** by the filing leg and unverified here — the `bara.standup` documents were not opened by the authoring run: the `operator-bara` label-scope count on team MBN moved 68 → 61 → 63 → 67 across the 2026-10-21, 10-22, 10-23 and 10-26 entries. The 10-22 entry attributed 1 of a -7 drop and reported the remaining 6 as unexplained; the 10-23 entry attributed its own +2 in full and carried the -7 forward in prose; the 10-26 entry attributed 2 of a +4 and carried both residues. Each entry obeyed the attribution clause above as far as it reached and none converted, so the conversion arrived on the third consecutive mention under step 3 — correctly, but five days after the only window in which the original -7 was still diffable. Same family as `APP-2215`'s counting-duty-with-no-service-duty gap, and distinct from `APP-2336`, which is the count being unfalsifiable for want of an identifier list rather than the residue having no disposition — APP-2674.) A bare number is unfalsifiable, so an under-report reads as a quiet day and survives until someone re-runs the read by chance. (Worked cases: the 2026-09-28 `bara.standup` entry reported two operator-routed items when `MBN-297` had rested in that exact shape since 2026-09-25, and the 2026-09-29 `a1.standup` entry reported one when a fresh workspace-wide read found `APP-1226` too, Blocked 19 days carrying `operator-a1` with no executor — two verticals, one signature — `APP-1843`.)

  **The review queue is read on the same basis, and its scope is workspace-wide.** **And each row the review-queue read returns carries a one-line disposition per identifier in the entry.** The rule above fixes the query, the scope, the time, the count and the identifiers behind it, and fixes nothing about any row inside them, so a row can be counted correctly on every pass and never dispositioned — present in the count, restated by it, and touched by nothing. So each identifier the read hands up is written with one line saying what became of it: restated, escalated by age, re-pointed, or explicitly unchanged and why; and the **oldest row is named with its age in days on every pass**, because age is the ladder's only lever on a hold that waits on an Owner sign-off. Escalating by age per `convention-linear`'s ladder is already written for the Backlog-raised carry set, and for overdue items keyed on `dueDate`, and neither carries itself over to the In Review `human` queue, where the age that matters is time spent waiting rather than a date on the ticket. This is a disposition per identifier and not a second read: the identifiers are already written with the count. (Canon's own case recurs. `MRP-53` above rested In Review fifteen days with no follow-up comment while the queue around it was counted — `APP-1888`. The same shape was seen again on `MRP-57`, In Review, Urgent, carrying `human` and `operator-mrp`, assigned, `updatedAt` 2026-11-11T07:19:15.014Z, against `MRP-62` and `MRP-80`, with 23 days since its last comment — **reported**. The filing note's own diagnosis is **false** on that read: a missing `priority` value cannot have excluded it from the carry-set query, since the priority carries a value, and its claim that priority and placement last moved on 2026-10-19 is contradicted by the `updatedAt` above. What survives is the comment gap, which is the gap this clause closes — `APP-3037`.) The rule above is written over the `operator` label; the stand-up's other standing count — the items awaiting the Owner's sign-off, read as **In Review** carrying `human` — is a queue by the same test and is written up the same way, with its query, its scope and the time it ran. Scope is the one thing that differs and the one thing that fails quietly: an In Review `human` item can rest on any project the Owner works, including one outside the vertical's delivery projects, so the read is workspace-wide by the vertical's `operator` label and bucketed by project afterwards, exactly as the queue and scope reads above are. A read confined to one project is reported as suspected-incomplete, naming the projects it covered, and is never handed up as a count. A project-scoped brief that excludes such an item is correct on its own scope and is not the defect; the cross-project count is. (Worked case: the 2026-09-29 `mrp.standup` entry reported the In Review queue as "two items, not ten" — MRP-24 and MRP-55, both `human`, both assigned to the Owner. The 2026-09-30 entry re-derived the read from the board and found three: MRP-53, `human`, `operator-mrp`, In Review since Reach delivered it on 2026-09-15, fifteen days with no follow-up comment and the oldest of the three, resting on the **Operations** project rather than Articles. That morning's Articles-scoped `task-daily-report` brief correctly excluded it, and the Operations project had posted no recent status update, so no other surface was placed to catch it. Which read the 29 September run used was not established, and this rule does not depend on it — `APP-1888`, the review-queue sibling of `APP-1843`'s operator-queue undercount. MRP-53's state, labels, project and In Review date were read directly on 2026-10-01 and are **observed**; the stand-up documents themselves were not opened.) **And the count is not the report — an item handed to the Owner is named with what he needs to judge it.** Scope above makes the count right and says nothing about whether the items inside it can actually be reviewed; an unreviewable item inside a correct count costs the Owner the sitting rather than the read. So for each In Review `human` item the entry hands up, test three things on the item itself and report the result, never a batch verdict: (a) the review surface **resolves and is current** — a preview or document link that 404s, or that was built from a base `main` has since moved past, is not a review surface; (b) where the item carries a PR, the PR is **mergeable**, and a conflicting one is reported as conflicting, by number, with what superseded it; (c) whether the item **gates** another ticket, named by ID. An item failing any of the three is reported as **not reviewable, with the one blocker**, and is never folded into the queue's count or handed up as part of a "batch pass": a count is for a set that is uniformly actionable, and one generic remark over nine items is the shape that hides the two that are not. The check is per item and cheap, and it is owed only by the items the entry actually hands up, not by the whole scope. (Worked case: the 2026-10-02 `a1.standup` entry listed A1-451 and A1-452 only inside a recounted "9 items In Review, human" line with a generic "batch pass" remark. A1-451's PR #15 was conflicting — A1-573, merged 2026-10-01, had replaced the Action section it edited — and both branch previews were built from a stale base, so neither showed Aled anything he could judge; both gate A1-433, the cycle's secondary objective, which no line named. The entry reported A1-573 as shipped without checking what it superseded, and spent its budget on count movement and a 50-day closure instead. `owner.standup-agenda` passed the pair on as an Overflow "batch" bullet, and Aled was asked to review something unreviewable — APP-1967.)

  That is what an operator hold looks like, because a hold is expressed by *clearing* the executor rather than by evicting it — no `agent`-group value, `operator-<venture>` set, the assignee cleared, the escalation category in a comment; "evict" was the mechanism of the old single-select shape, not a requirement. Re-routing a held ticket — setting `agent:F0-RGE`, or `human` plus Aled — takes it **out of the queue and leaves it in scope**. The daily read resolves the **queue first**, then the wider scope. A ticket with no executor **and** an operator label is therefore a valid held state, never an anomaly for an executor-presence sweep to repair; no executor **and** no operator label stays the anomaly (`skill-triage`). **The queue test is that label pair and nothing else — `human` is not a proxy for it.** Whether a held ticket also carries `human` is immaterial to the test, so a check that filters on `human` to find "the ones that are Aled's to read" is not the queue read and will not find them. The shape to watch is `operator-<venture>`, no executor, **and no `human`**: a genuine held operator judgement that reads on any scan exactly like an ordinary unlabelled review item, because the one visual cue the eye uses is absent. Run the read as defined — the label pair, workspace-wide — and where a result also carries no `human`, name it in the entry as a **silently-held** item, so the line says it was found by the test rather than by the cue. **And the read is reported whether or not it returns anything.** An entry written by a run that never ran this read is indistinguishable from one whose read came back empty, so the omission is invisible on exactly the days it matters, and five notes in this family have now been closed against a rule nothing could test for absence. So the entry carries the silently-held read's **own line, in every case** — the query, its scope, the time it ran, and the count **including nil**. `silently-held: operator-a1 + no executor + no human, workspace-wide, read 07:14Z — nil` is a complete line; omitting the line is a defect, not a nil result. **Epic-type rows are excluded before the test is applied, and the line says how many were excluded.** An epic carries no executor by design — it is an outcome closed by the operator once its children are done, and it is progressed through their children rather than worked directly (`skill-triage`; `convention-linear`, *Structure*) — so it satisfies the query and is never the thing the query is for. Without the exclusion the read is noisy enough that a run either hand-filters it, which cannot be written into the line this read is required to produce, or reports a headline count that buries the one or two genuine items inside it. So filter on the ticket type before the label pair is tested, and write the figure both ways: `silently-held: operator-a1 + no executor + no human, workspace-wide, read 07:14Z — 8, after excluding 19 epic rows`. The exclusion is a type filter and nothing else: a non-epic row with no executor stays in, however structural its reason looks. **And no state set narrows it: the queue read is the label pair, workspace-wide, in every state.** The recipe's opening names Blocked, In Review, Todo and In Progress for *what is stuck*, and a run that carries that state set into this read loses exactly the item the read exists to find — a held judgement rests as happily in a backlog-type state as in Blocked, and the longer it rests the more settled it looks. The Scope/Queue split is defined on the labels and on nothing else (Owner ruling, Aled 2026-09-04, APP-1117), so the state set here is the `statusType`, for the same reason the overdue read below keys on the date rather than on the states this recipe names. Run it across every open state, including Backlog, Refinement and a team's Refinement-equivalent, and bucket by project afterwards. (Worked case: MRP-46 carried `operator-mrp` with no executor, no `R3-LAY` and no `human`, resting in `Defined` — so it fell through the carry read, which filters on `R3-LAY`, and the review-queue read, which filters on `human`, at once. A genuine Owner question had sat on it since 2026-09-15 and was named in no `mrp.standup` entry for 27 days, found on 2026-10-12 only when that run applied the workspace-wide label scan to backlog-type states as well. **Unverified premise:** the ticket reading back Medium against a 2026-09-15 comment stating the ladder was run to Urgent is a discrepancy, not a diagnosed cause — whether `save_issue` priority writes have a reproducible no-op on this team is not established, and the read-back obligation that already governs it is in `convention-linear`; this flag covers that one priority write and nothing else — APP-2270.) The loaders inherit this recipe and must not digest it: a loader that summarises the recipe in a parenthetical names the reads it happens to mention and silently drops the rest, which is how a rule present in canon stops being run. (Worked case: on 2026-10-08 both `a1.standup` and `mrp.standup` omitted an item in exactly this shape — A1-574, Todo, `operator-a1, task, work:infrastructure`, no executor and no `human`; and MRP-1, In Progress, `operator-mrp, work:configuration, epic`, likewise — each caught only by `task-owner-standup`'s own workspace-wide backstop. Both loaders' step 2 cited this recipe as "(state buckets for what is stuck, `completedAt`/`createdAt` for what moved, never `updatedAt`)", naming neither the queue read nor this check. It is the condition APP-2034 set against the APP-1965 rule, met five days inside its own window, and the fifth note on one root — APP-1933, APP-1965, APP-2032, APP-2034, APP-2168. The two stand-up documents were not opened from the refine surface, so the omission itself is the filing leg's report and is unverified; that flag covers the two entries and the two tickets' fields only, not the canon placement, which was read live.) Backfilling `human` onto such a ticket is the operator's call on that ticket, not this read's, and the read never waits on it. (Worked cases: A1-346 sat In Review carrying `operator-a1`, no executor and no `human` from 2026-09-29, and three consecutive `a1.standup` entries reported "no other no-executor holds found" — none of them tested the no-`human` shape; it was found and ruled by `a1.standup` on 2026-10-02. A1-479 is the second instance in the same shape, found on 2026-10-02 not by `a1.standup` but by `task-owner-standup`'s workspace-wide operator-queue re-derivation, where it happened to feed a live Owner ask so no harm landed. Both tickets were still in that exact shape when re-read on 2026-10-05 — APP-1965.) **Then the scarce-resource read** (Owner decision, Aled 2026-09-03, APP-962): group the vertical's open work by the **precondition it waits on** — the host, the Owner's eyeball, a credential, an unmade decision — and read each group as a set. Collisions and ordering hazards fall out of the grouping without reading any ticket for strategic consequence (four host items waiting on one terminal session showed the APP-915 → APP-929 ordering hazard the moment they sat side by side, 2026-08-17 — APP-982). This is a deliberate partial: routing (step 5) catches what a delivery leg recognises as a question; this read catches what shares a precondition; work that is unflagged *and* shares no scarce resource is caught by neither, and the full in-flight consequence sweep is **not built** — the evidence for it is one instance, and it returns to the table only if a second unflagged-and-unshared case appears. *What closed and what was raised* are read time-windowed on **`completedAt` and `createdAt`**, never `updatedAt`; both are set once and cannot be re-stamped. **`updatedAt` is a cache key, not an activity log.** A bulk sweep re-stamps it across unrelated tickets to the millisecond, so a windowed `updatedAt` read is neither evidence of movement nor, by absence, evidence that nothing is stuck (41 Apps tickets "updated" on 2026-08-21 with zero completions; MBN-253, Done since 2026-08-10, returned as recent activity on 2026-08-22). A truncated read (`hasNextPage: true`) is not the whole set. The narrow queries are also the cheap ones — the wide read overflowed at 81.5k characters on 2026-08-19. State *transitions* are not derivable from any list field; "what got stuck yesterday" is read from the standing Blocked bucket and, where it matters, from `stateHistory` per ticket (`task-daily-report` § *Window*; APP-204).

  **A carried item is re-read before it is restated (APP-1477).** The recipe above says how to find what is stuck; it does not say what to do with an item found stuck yesterday. Restating is a read, not a recall. Before an item that appeared on a previous entry appears again, re-read its current state from the board **in this run**, and **name the state and the time of that read in the line itself** — `Todo, read 07:11Z` — so a later run, and the Owner, can tell a re-read from a copy. An item whose re-read comes back closed, cancelled or re-routed is not restated: it is closed out in one line naming what changed and when, and any escalation climbing on it is withdrawn. Age is a reason to escalate, never a substitute for the check — `convention-linear`'s ladder carries the nearest existing rule, but its step 0 re-verification is scoped to claims about a connector-held resource at the moment of escalation, and daily restatement is both the more frequent path and the one with no check on it. This is the first-level report's own duty: `task-owner-standup` consolidates, it does not re-verify, so an item that is wrong here is wrong in the room — with one exception: that task runs the operator-routed queue read itself, and an item it finds that this entry did not carry is reported there as a gap in this entry (`task-owner-standup`, Step 1, input 3). (Worked case: A1-363, the a1.Muse chase, was cancelled 2026-09-14 at 08:56Z and named as "Urgent, Todo, still unsent" on every `a1.standup` entry from 09-09 through 09-15 — the last written nearly a day after the cancellation, on the stated ground that it was "already at max priority and named on every entry since 09-09; not re-argued further, just the age". It reached the owner stand-up as live six days after it stopped being live. Re-read 2026-09-18 at 04:37Z: A1-363 is `Canceled`, `canceledAt` 2026-09-14T08:56:32Z, unchanged since — APP-1477.)

  **And the same read stands behind calling an item new.** The rule above binds a restatement and has no equivalent for the opposite claim, though the two rest on identical evidence: has this been addressed, and where. So before a stand-up, a standing agenda or any report characterises an item as **new, unaddressed or never answered** — or characterises **what the item needs next, or how near done it is**, which is the same claim on the same evidence reached from the other end — its **full comment thread is read to the end, not sampled**, and the line names that read exactly as a restatement names its own. The readiness claim is in scope because it is the shape that *escalates*: "one publish session away" moves a priority, and the objection that would have stopped it sits in the newest comment the pass did not read. (Worked case: `bara.standup.2026-W41` of 2026-10-06 and 2026-10-07 both named MBN-280 as one Shopify-admin publish session from done, and the 10-07 entry escalated it High to Urgent on that basis. MBN-280's newest comment at the time of both reads — a `[coordinate]` comment of 2026-10-06T07:04:26Z, still newest and still unanswered on 2026-10-09 — flags an unresolved conflict between two Owner-attributed rulings on the published returns-window figure, 21 days against 30, and asks for one line from the Owner before publish; publishing on the wrong figure would have put a wrong policy live. Both entries satisfied APP-1477's state re-read one paragraph up, and neither claimed the item was unanswered, so neither limb of this paragraph reached them — the third instance of this root after APP-1935 and APP-1976, on a third axis — APP-2167.) A thread's newest comments are where a ruling lands, so a pass that reads the body and the oldest comment can report an item as open having skipped the answer to it. This direction is the more expensive of the two to get wrong: a stale restatement repeats something that was once true, while a false "never answered" manufactures an Owner item out of a settled one and carries it into the standing agenda as live. `convention-ticket` already rules the symmetric case one level down — a stated absence is a claim too, tested against the artefact rather than the thread that asserts it — and this is that rule on the reporting surface. (Worked case: the 2026-09-30 `mrp.standup` entry reported MRP-23's 12 August question — the approved-full-set-versus-proposal split, and what opens the series — as never answered and never previously carried in a daily entry. It had been answered on 2026-09-14 by an operator ruling on that same ticket resolving both halves, with the 2026-09-20 and 2026-09-28 comments both proceeding on it. The 2026-10-01 run re-read the whole thread before restating, found the ruling sixteen days old, and closed the item out in that entry instead of carrying it; no Owner time was lost, but it would have reached `mrp.owner-session-agenda` as a live async item had Monday's refresh inherited it from the entry rather than re-grounding — APP-1935.) **Name which read, because a state read never stands in for the thread read.** This rule and the restatement rule one paragraph up bind the same sentence and are satisfied by different calls, so a line naming *a* read satisfies the cheaper one and reads as having satisfied both. A line characterising an item as new, unaddressed or never answered — or naming what it needs next or how near done it is — therefore carries its **`list_comments` read — read to the end — with its time** (`MBN-321, thread read to end 07:19Z, no ruling`), distinct from and in addition to any state read on the same line. **And the call is added to the recipe for these items only.** The recipe's reads return state, labels, priority and dates and no comments, so this is the one rule in the daily pass that needs a call nothing lists — which is why it is the one that does not fire, while its zero-cost sibling fires reliably. List the items the entry will characterise as unanswered first, then read each one's thread before the line is written. **A state read agreeing with the claim is not corroboration of it.** An Owner ruling delivered as a comment moves no field, so the ticket reads identically before and after it, and the cheap check passes precisely on the items where the expensive one would have failed. (A ruling that exists only as a comment is **not yet recorded** — `convention-decision-log` — and that is the ruling writer's duty at the time of the ruling; it never relieves this read.) (Worked case: `bara.standup.2026-W40` reported MBN-321 as "unruled 6 / 7 / 8 days" and listed it item 1, worst-consequence first, waiting on you, on 30 September, 1 October and 2 October. Each entry re-read the state and timestamped it — `read 07:19Z`, `read 07:05Z` — correctly, per APP-1477. The state was `Todo` on all three days and that was true, because the ruling of 2026-09-29 08:47Z never moved the ticket out of Todo. The same week, `bara.owner-session-agenda` of 2026-09-25 carried MBN-298 as session item 3 stating "no ruling on the thread", a week after it was ruled on that thread on 2026-09-18, and restated a recommendation — "set it as orders-per-week, not a date" — that the ruling had already superseded by setting the trigger cost-based. Two items, one surface, one week, with APP-1477's rule obeyed on the same line APP-1935's was not — APP-1976.)

  **And both halves of that read bind this loop's own entry, not only the consolidation above it (APP-2636).** The two rules above govern a *carried* item and a *new* one. A claim about what a ticket's thread contains is the same read reached from a third side, and it is the vertical's to make: `task-owner-standup` consolidates and does not re-verify, so an entry asserting that a date moved with no operator action behind it, or that a ticket carries no comments, is wrong in the room exactly as written. Both directions cost the same read and both have been got wrong. Before an entry characterises a change as unexplained drift, read the ticket's comments to the end — an Owner ruling applied by an assistant leaves a thread comment and no actor in the field, so unattributed in the field is not unattributed on the thread, and a settled item written as open spends the consolidated agenda's lines on corrections instead of on the day. Before an entry asserts an **absence** — no comments, no reply, nothing on the thread — make the same read to the end rather than sampling, because the absence claim rests on identical evidence and is the more expensive of the two to get wrong: it is restated verbatim on the following day's entry unless something contradicts it. Where a prior day's agenda has already named an entry's claim as wrong, that claim is re-read before it appears again, never carried forward. (Worked cases: the A1 entry of 2026-10-23 reported A1-429's due date as pushed out nine days "without an operator action behind it", when the thread's top comment of 2026-10-21 is the Owner's stand-up ruling to push the date to 1 November, applied by Aide; the same entry listed A1-696 and A1-543 under *Needs you today* as a release-or-hold pair that the Owner's 2026-10-21 ruling had already settled. The BARA entries of 2026-10-22 and 2026-10-23 both stated MBN-336 had no comments, with a `[triage]` comment on the thread at 2026-10-22T06:23:29Z — and the 2026-10-23 repetition came the day after the agenda named the error. A recurrence after APP-2337 closed, family with APP-2420 and APP-1643; the comment IDs, timestamps and agenda entries are the filing run's **report** and are unverified here — APP-2636.)

  **And "ruled, not yet enacted" is a third result of that same read (APP-2537).** The two rules above bind what a surface may *say* — a restatement, and a claim that an item is unanswered — and both are satisfied the moment the thread has been read to the end. Neither asks what the read **found**. So where the thread carries an **Owner ruling newer than the ticket's last field change**, that is its own finding rather than a clean pass: it is reported as **ruled, not yet enacted**, with the ruling's date, and the reading surface **enacts it inside its own grant or names who must**. The result the output has to carry is that **"no ruling" and "ruled, unenacted" are different results, and only the first justifies re-listing the item** — an item re-listed on the strength of a thread read that found a ruling is worse than one re-listed with no read at all, because the record now shows the thread was read. `convention-decision-log` already puts the write on the receiving pass — *"the pass that receives the ruling either makes that write in the same pass or files it in the lane that owns it"* — and that duty is what this result hands it; what was missing was a **name for the finding**, so a surface that read the thread correctly had nowhere to put what it saw and passed. There is no cheaper test, because a ruling delivered as a comment moves no field: the ticket reads identically before and after it, so every state read passes on exactly the items this one catches. (Worked case, **reported**: the Owner ruled three Apps items in one session on 2026-10-19 — APP-2360 approving three projects as In Progress, APP-612 accepting a 16 October date with a derivation to follow, APP-1209 setting the Apps envelope at zero on a rolling weekly window with spend-to-date unknown. The `task-apps-operator-loop` run of 2026-10-21 found all three unenacted: two project statuses still Backlog, APP-612's `dueDate` still 2026-09-30 with the accepted date itself five days lapsed, and `apps.mandate`'s values still blank — two days and two daily stand-ups, with APP-2360 and APP-1209 still carried as Open items on the standing agenda. It surfaced only because that run read each Open item's full thread under the rule above, which exists to prevent a false "never answered" and caught this as a side effect, on the one cadence that runs it — APP-2537.) **One limb is not authored here.** Whether a scheduled triage pass may *write* within a ruling's own terms is a change to that pass's **grant**, and grants are the Owner's to give, so it is named as a residual and left to him.

  **And a membership characterisation is re-derived from the label set, because a state read never stands in for the label read.** The two rules above bind what an entry says about an item's *state* and about whether it has been *answered*. Neither binds the third claim a daily entry routinely makes: which side of the **Scope/Queue split** an item sits on — `operator-<venture>` with an executor is scope, `operator-<venture>` with none is the queue. That claim rests on the ticket's `agent`-group labels and on nothing else, so re-reading the state satisfies APP-1477's rule on the very line it leaves this one untested, and the re-read comes back agreeing precisely because the state really has not moved. So where an entry describes a named item by its queue membership — a no-executor leave, a hold, a judgement pending on the operator — the line carries the **label read that produced it**, with its query, its scope and its time, exactly as a count does, and a characterisation that appeared on a previous entry is re-derived rather than inherited from that entry's prose. The failure is quiet in both directions: a leave that has since gained an executor keeps being reported as pending the operator's judgement, and the queue it is counted inside reads as holding two when it holds none. (Worked case: the `apps.standup` chain of at least 2026-10-01 and 2026-10-02 described APP-514 and APP-509, both cOS.Build, as "the operator queue's two pre-existing no-executor leaves". Read directly on 2026-10-05 and again on 2026-10-06, both carry `operator-apps` **and** `R3-LAY` — an executor present, so both sit in scope and the queue re-derived is empty, not two. Both also moved In Progress → Backlog on 2026-09-30 at 11:24Z, and the APP-1530 thread of 2026-09-25 had called them "no-executor **In Progress** leaves" — a third shape again, so which of the label and the state went stale first was not established from the surfaces available, and this rule does not depend on it. Figure sibling: APP-1963's Backlog-plus-`R3-LAY` count that moved 34 to 36 with nothing to attribute it to — APP-2032.)

  **And an overdue date is its own read, because no bucket read and no label read finds it (APP-2131).** The three rules above bind what an entry says about an item it has already found. Nothing in this recipe finds an item whose only abnormal signal is its **date**: *what is stuck* is read by bucket, the scope and queue reads are read by the `operator-<venture>` label, and the carry read is read by the `agent:R3-LAY` executor. An item correctly filed, correctly stated, carrying no operator label and no routed executor is therefore invisible to every one of them while its due date passes — and the longer it is overdue the more settled its state looks, so nothing in the entry ever changes to mark it. So the pass adds one read keyed on the date and on nothing else: **the projects the operator's profile declares under *State sources*, with `dueDate`, `statusType` and `priority` requested in `fields`** — `priority` because an item the entry calls overdue is an item whose priority field is a claim about the same urgency the age is describing, and an item sitting at **None** past its own due date is itself a hygiene defect to correct in that pass, not a figure to restate. `convention-linear`'s stalled-item ladder climbs one rung at a time and assumes every surfaced item is already on it; an item that starts at None is outside the ladder entirely, so the age-based narrative reads as the escalation while nothing escalates. Correcting it is a reversible, in-vertical, zero-spend write of the kind this recipe already permits, and the entry names the correction it made. **The review-queue read carries the same field for the same reason**, paging through `cursor`, discarding `completed` and `canceled` client-side, and carrying every remaining ticket whose `dueDate` is strictly before today — oldest date first, escalating by age per `convention-linear`'s ladder exactly as the carry read does, and standing down to a recommendation where the date is already under an open rescope (*Escalating an Owner-blocked stack*, APP-866). **It is keyed on the date, never on the operator label.** A sweep scoped by `operator-<venture>` reproduces APP-2034's blind spot one signal over, because the item that needs finding is exactly the one the label does not cover; for the same reason the state set is the `statusType`, not the states this recipe names, since an overdue item sits as happily in Refinement as in Todo. **Both the filter and the sort are client-side, and by necessity:** `list_issues` carries `dueDate` in its `fields` enum but has **no `dueDate` filter parameter**, and its `orderBy` enum is exactly `createdAt | updatedAt` with no direction argument, so "overdue, oldest first" is a pass over the returned pages and never a query argument. (Worked case: A1-527, "GATE: Aled to supply real photography for the showcase", due 2026-10-01, sat in A1's `Refinement` — a backlog-type state — with labels `human` and `task` only, no `operator-a1`, assigned to Aled, in *Bang Bang City · Site & collective*; it appeared in none of the `a1.standup.2026-W41` entries for 10-05, 10-06 or 10-07 and was six days overdue when `task-owner-standup`'s project-status cross-check named it on 2026-10-08. Distinct root from APP-2034's no-executor miss: that item is missed because the queue backstop reads executors, this one because every read here reads something other than the date. Whether it was also silently overdue in the 10-05 and 10-06 entries is **not verified** — APP-2131.)

  **And a cycle commitment's own pass beat is its own read, keyed on the beat's date and never on the ticket date field.** The read above is a date-field pass, so a beat dated only in prose — in the goal artefact, in a ticket thread, or in a calendar note, with no date field set on any ticket — is found by it and by no other daily surface, and the board goes on asserting a precondition that changed off-board while the entry has nothing to say about it. So the pass reads the beat's date wherever it is stated, in whichever of those three places states it, and where that date has passed **the vertical's next daily entry names the beat, its ticket and that ticket's board state**. **It does not guess between the three readings** — the beat ran, it did not run, or it ran and was never written back — because each carries a different next action and no one of them can be told from the others off the board alone. That is the same discipline this recipe already applies to an unruled Owner-session item, now on the daily cadence rather than the weekly one. (Worked case: a committed goal's pass beat was dated only in prose, in the goal artefact and a calendar note, with no date field on any ticket, so the date read above could not reach it and the beat's date passed with the board still asserting the precondition the beat was to settle. Second instance on this thread, after the undated-signal miss the rule above records, which is why the beat's own date now carries a read of its own rather than a caveat — APP-2131, APP-2339.)

  **And the readiness limb carries a fourth read — the ticket's own body, counted, because checkbox state is a field no claim-time read in this recipe opens.** The thread rule above binds a readiness claim to the comments and the restatement rule binds it to the state, and a ticket whose acceptance criteria are nearly all met reads identically on both to one whose criteria are nearly all open — `Blocked, Urgent, 38 days` either way. The promotion gate earlier in this loop does open the description, but by its own words as a **heading-presence check only, never a judgement on the criteria themselves**, so nothing here ever reads what the boxes say. So where a surface characterises a ticket by **how near done it is** — *one look away*, *one session from done*, *ready but for X* — that run reads the ticket's `description` and the line states the count it found and the time of the read: `A1-545, 7/8 AC, 5/5 DoD, read 12:2xZ`. A count is falsifiable; "one look away" is not. The read is scoped to the readiness limb alone and adds one `get_issue` per item a surface calls nearly finished — on the page that produced this rule, one item. `description` is not returned by `list_issues` and is dropped by a `fields` selection that omits it, both of which `convention-linear` already states, so the field is named explicitly or it is not read. **And the count does not settle the disposition — the newest comment on the open criterion does.** A box and a ruling can disagree in either direction, so the count is reported beside the thread read of the limb above and never in place of it, and the symmetric failure is named too: a ticket with **zero** boxes ticked, reported as nearly done on the strength of a hand-off comment, fails this test from the other side. (Worked case: `a1.owner-session-agenda` carried `A1-545` → `A1-564` in *Async* across four consecutive refreshes, 2026-10-06 through 2026-10-27, as "one 30-minute Firmup console review" and "the oldest Urgent block in the vertical", each refresh re-reading and timestamping the state — `Blocked`, `Urgent`, 31 then 38 days — correctly, per the rules above. The description read that finally executed the declared re-scope found **seven of eight acceptance criteria and all five definition-of-done boxes ticked**, PR #35 attached, and the single open criterion a retire/redirect the fleet does rather than a gate on anyone looking at a preview; `blockedBy` was `A1-564` alone, a dispatch asking for thirty minutes "after 20:00 today" where today was 2026-09-29. Four refreshes spent an Owner ask on a slot that would have unblocked nothing. A1-545 is now `Done`, all eight criteria and all five DoD boxes ticked and its PR squash-merged, and the open criterion's real disposition lived the whole time in two `[operator-a1]` rulings on its thread, of 2026-09-29 and 2026-11-03, the later of which left the criterion standing as written and claimable — which is why the count is reported beside the thread read and not instead of it. Fourth evidence surface on the readiness limb of `APP-2167`, after state (`APP-1477`), thread (`APP-1935`, `APP-1976`) and currency (`APP-2713`); the A1-545 and A1-564 figures and the four quoted refreshes are **observed**, and no repo or CI surface was read, so PR #35's state beyond the attachment and the ticket's own ticked DoD is not asserted — APP-2849.)
  **And a disposition that cites a condition is re-tested against that condition's current value, because a correct reason goes stale without the ticket moving at all.** The reads above test an item's state, its thread, its labels, its date and its own body; none of them tests the **reason** a previous pass gave for leaving it where it is. A backlog disposition resting on a named blocking condition — a project on `Hold`, an unruled Owner question, a named blocker's own state — is correct when it is written and keeps reading as correct for as long as it is quoted, because the citation is specific, dated and honest and the ticket's fields agree with it on every later read. So where a carried item's newest disposition comment rests on a named condition, the pass **reads that condition's current value in the same run** and, where it has changed, reports the item as **disposition stale — the cited condition has cleared**, naming the condition, its new value and the date it changed, and routes it for re-triage instead of carrying it forward on the old reasoning. It costs one read per cited condition, and conditions repeat across a batch, so a set of tickets reversed together costs one. The trigger worth naming is a **project leaving `Hold` for a live status**: every ticket whose disposition cited that Hold goes stale in the same instant, not one of them moves, and the carry set goes on restating a reason that is no longer true. (Worked case: `APP-957`, `APP-956` and `APP-958` — project bot.Trader-B, `Backlog`, `agent:R3-LAY`, created 2026-08-15 — each carry the identical `[triage]` comment of 2026-10-27 recording a promotion to Todo/`F0-RGE` reverted back to Backlog/`R3-LAY` **because the project read `Hold` at the time**, correct then and citing `APP-2025` as the standing parked-or-live question. bot.Trader-B's Hold lifted on 2026-11-10 by Owner ruling, six days before the 2026-11-16 `bottrader.standup` run that found all three at 93 days old; the lift, the 2026-10-27 reversal and the entry chain from 2026-09-09 are **reported** by that run. **Observed** on the board 2026-11-17: all three still `Backlog`, `statusType` `backlog`, carrying `R3-LAY` and `operator-bottrader`, their newest touch the filing run's own at 2026-11-16T07:31:22.715Z — so nothing has re-triaged them. Their absence from the entry chain is a separate matter, **covered by the carry-set read above**, which is project-scoped and would have returned them; nothing is authored for it. `APP-3117`.)

  **The emit surface** (APP-983). The stand-up writes its summary to the vertical's daily stand-up document, `<vertical>.standup`, on the vertical's initiative — the same document shape as the standing agenda — as one dated entry per working day. Native status updates were considered for this and rejected: they carry the weekly health signal, five daily entries between each weekly one bury it (APP-867 records the same collision in the other direction), and they are per-project where a stand-up is per-vertical. Three rules govern the entry: (a) read the previous entry first and never re-present an ask that has not moved — an item is escalated, not repeated; (b) a fixed per-vertical budget — the three to five lines that need Aled today, not the run's narrative — and a portfolio operator compresses per bet before handing up, since a raw Apps read is mostly the Pulse queue talking. **The owed lines sit outside that budget and are never traded against it.** The silently-held read's own line, the operator-queue and review-queue lines, the carry-set reconciliation and the Owner-session line are owed in **every** entry whatever the budget holds; a run short of room compresses the content bullets instead of dropping one of them, because a dropped owed line is invisible on exactly the days it matters — a nil result and an unexecuted step read identically once the line is gone (`APP-2913`); (c) a flag repeated from the previous entry converts to an action or an escalation with a recommendation, never a third mention — **and a queue is a flag.** A *set* that stays the same size while nothing in it moves — a review queue "unchanged at nine", a standing blocked list — reads as "unchanged, so nothing to escalate", when what is aging is the flag itself and not any one member; rule (c) fires on it exactly as it fires on a single item. **Its conversion is one consolidated block, worst consequence first, naming each member once** — never an escalation on a single member, which picks a victim out of a stable set instead of reporting the set. (Worked case: `mrp.standup` reported the In Review queue "unchanged at nine/ten" on 21, 22, 23, 24 and 25 September — five plain restatements, each run's own re-read confirming "unchanged" and stopping there — before the 2026-09-28 entry converted it. The rule ran on the sixth day, not the second — APP-1810.) **(d) The entry is the run's deliverable, so its absence is reported, never passed over.** A pass that reaches its end **without an entry written says so plainly in its own output** — naming the vertical and what stopped it — rather than finishing on the read; the three rules above govern what an entry contains and none of them fires when no entry is produced at all, which is how the step went unexecuted in every vertical until 2026-09-09 (all five documents were created that day, none earlier — APP-1215). The check costs nothing extra, because rule (a) already reads the previous entry: on a vertical this loop has been running, an absent predecessor is itself the finding — and so is a **gap between that predecessor and today**. Rule (a) already has the previous entry's date in hand, so where it is more than one working day back, today's entry names the working days that carry no entry and reports them, exactly as a wholly absent document would be reported. A document that exists and is written to on a normal cadence still reads as healthy with a hole in the middle of it, and that is the one shape an existence check cannot express. The pass does not guess the cause: whether the schedule did not fire or a run fired and exited before writing is `skill-task-health`'s question, and the entry says which working days are missing rather than why. (Worked case: `a1.standup` carried dated entries for 2026-09-08 through 2026-09-11 and then jumped to 2026-09-14, with nothing for 09-12 or 09-13 — no stub, no "nothing to report" line — caught only because rule (a) opens the whole document rather than testing for its existence — APP-1432.) The systematic form of the same check is the artefact-existence check on this row in `skill-task-health` **Pass B**, which reads the expected surface directly and would have caught all five absences without waiting for a stand-up to notice its own. The week's entries feed the operator's Monday headline. Relay's `task-owner-standup` reads the five documents and the morning's project updates and produces the single 09:00 agenda; nothing else consolidates them.

  **Every ticket reference in the entry is a bare identifier, written at the point of composition (APP-2753).** While each bullet of the entry is drafted, the ticket is named by its bare identifier as plain text — `A1-721`, `APP-1234` — which Linear resolves into a live mention on save. Never compose an `<issue id>` tag by hand, never fill one with a placeholder or invented UUID, never guess an `href` slug, and never take the markup shape of a reference from the previous entry's bullets. Where a real tag is genuinely needed, the `uuid` and the `url` come from a `get_issue` read of that ticket and from nothing else: the identifier does not carry them and cannot be converted into them. The argument is the asymmetry between the two reads. `list_issues` returns the human-readable identifier and not a UUID, so a run composing from it holds exactly the material to fabricate one and nothing to check it against. And the failure is invisible on save, because Linear downgrades the malformed tag to a plain markdown link: on the page that reads as a styling difference while whatever wrong URL was guessed is silently preserved, so the entry looks written rather than broken. **Self-catching is not self-prevention** — a run that notices the fabrication and repairs it has still fabricated, and the repair is only as good as that run's attention on the day. The rule belongs here rather than in each loader: each of the five `task-*-operator-standup` loaders states that behaviour is changed in `skill-operating-loop` and not in the loader, and `core-operating-model`'s thin-loader split puts behaviour in the composed artefact with only sequencing in the task — so a composition rule written into five loaders is five copies of one sentence, four of which drift, which is the shape the lineage below records: the fix landed in one loader and the gap stayed open in four. (Worked case, **observed** from `APP-2753`, read first-hand by this pass: the 2026-10-29 `task-a1-operator-standup` run hand-authored `<issue id>` tags with fabricated placeholder UUIDs and guessed URL slugs while drafting the `a1.standup.2026-W44` "moved since yesterday" bullet for five completed tickets. The five-ticket repair by `get_issue` read, and Linear's downgrade of the malformed tags to plain markdown links preserving a wrong href rather than a merely unstyled correct one, are the filing run's **report** and are not independently verified here. The lineage is **observed** from the board: `APP-1326` closed 2026-09-14, `APP-2166` 2026-10-09 and `APP-2512` 2026-10-26, whose remedy landed as an execution step in `task-apps-operator-standup` Step 2 and whose close named the sibling loaders as uncovered — then `APP-2753`, filed against one of those named siblings three days later.)

  **The document is bucketed by ISO week, and the document named above is the index (APP-1714).** One monotonically growing document per vertical fails on the read side, not the write side: measured 2026-09-25, `a1.standup` carried 78,294 characters of content across 11 dated entries — about 7.1k per entry — and `get_document` on it spilled to a host tool-results file rather than returning. That spill is the recoverable form; `convention-linear` (*Reading Linear safely*) records a **harder** one at around 61k characters that returns an error with **no persisted payload to open**, whose only documented recovery is slice-verification on the *write* side and therefore no help to a read. Rule (a) — read the previous entry first — is the step that breaks when the read fails, and unlike the decision log there is no bucketed child to fall back to. So: **`<vertical>.standup` is the index, and each working-day entry is appended to that ISO week's child, `<vertical>.standup.YYYY-Www`**, created on the week's first write. The threshold binds on the **returned payload**, not on content: Linear expands each bare `<TEAM>-###` identifier into a full `<issue …/>` tag on read, which roughly doubles a five-entry week, so a week whose content measures about 36k can return something near 78k. Measured 2026-11-06, `a1.standup.2026-W45` returned **77,731** characters on content of **39,258**, and `bara.standup.2026-W45` returned **62,771** on **23,996** — both five-entry weeks, both past the recorded hard-error figure on the *returned* payload while sitting well inside it on content. The ISO week stays the right bucket, and a monthly bucket would still rebuild the fault. What changes is the **read**: a child that spills is read from the host tool-results file the error names, sliced by character range, and the entry says it was read that way rather than reporting the document as absent (`APP-2912`). The index carries one row per week pointing at its child, and the week's child is where rule (a) reads: the current week's, and on a week's first working day the previous week's, resolved from the index — bounded in both cases, never the whole history. Rule (d)'s gap check reads the index's week rows as well as the current child, so a hole spanning a week boundary is still visible. Four mechanics make this cheap. **Append, never re-emit** — `save_document`'s `patch` with `{"op": "append", …}` adds an entry without touching what is there (APP-1667), and the same call's `prepend` adds the index table to an existing document without reading it. **Do not rewrite the pre-bucketing body**: on the first run under this rule, prepend the index table to the existing document and leave every historical entry beneath it as the index's archive row — a rewrite of a 78k document by hand is the thing canon already forbids, and the archive is never on a bounded read path again. **File the index and every child with the parent** `project` **set** — the project the vertical's operator profile names under *State sources*, named and not derived, exactly as this artefact takes its mandate and sources from the operator instance. `convention-linear`'s filing rule sets `project` as the parent and its safe lookup is a project-scoped listing paged to the end on exact title equality, so a document parented only to an initiative cannot be resolved by the rule that is supposed to resolve it; measured 2026-09-25, all five stand-up documents carry `project: null` with an initiative parent, so the run that next touches a stand-up document applies the fix in that run: prepend the index table, create the ISO-week child, set the `project` its operator profile names, and say so in its report. Recognising the shape and filing a note about it is not compliance — the document is still unbucketed and still unfindable by the rule meant to find it, and the note costs a drain cycle to conclude what this paragraph already says. (Worked cases: `a1.standup` and `bara.standup` were fixed in their own 2026-09-29 runs; `apps.standup` and `mrp.standup` filed notes instead and were still `project: null` with no ISO-week child on 2026-09-30 — `APP-1842`, `APP-1815`.), and where the initiative grouping is still wanted it is a link in the index's header rather than the parent. **And resolve the child by that same paged, project-scoped, exact-title lookup before creating it** — a dotted index shares its title as a prefix with every child, so a `query` search returns the children and a first-page miss is never proof of absence (APP-1576). (Worked case: the `task-a1-operator-standup` run of 2026-09-24 read `a1.standup` through the soft-spill path, appended the day's entry by `patch`, and left the document at about 79.5k characters, already past the recorded hard-error threshold and climbing about one entry per working day, with no bucketed child to fall back to and no project parent to be found by — APP-1714, same root as APP-906, whose decision-log fix this applies to the stand-up surface.)

  **And the week boundary is tested before the append, never inferred from the last entry (APP-2513).** The rule above creates the child *on the week's first write*, which fixes when a child comes into being and leaves the **test** for that moment unowned: a run that resolves the index, finds a child and appends to it has done everything this paragraph asks and has nowhere been obliged to ask which week it is in. So the append is preceded by one comparison, on reads the run is already making — **derive today's ISO week, read the week the index's current row names, and where the two differ, create that week's child and move the current marker before the entry is written**, the child by the same paged, project-scoped, exact-title lookup above and the index by `patch` so no historical row is rewritten. Entries already appended to the previous week's child are **left where they are** and named in the new child's first entry: `convention-linear`'s document-safety rules make a hand-cut of filed content the more expensive error, and the archive is append-only by design. **The check belongs here and not in the loaders.** Each of the five `task-*-operator-standup` loaders states that behaviour is changed in `skill-operating-loop` and not in the loader, and `core-operating-model`'s thin-loader split puts behaviour in the composed artefact with only sequencing in the task — so a rollover test written into five loaders is five copies of one rule, four of which drift. (Worked case, **reported**: ISO week 2026-W43 began Monday 2026-10-19, and the `bara.standup` entries for 10-19 and 10-20 were appended to `bara.standup.2026-W42`, created 2026-10-12, while the index's current row still read 2026-W42 — last updated 2026-10-12T07:23:33Z and never refreshed, so the index pointed a week behind the writes. The 2026-10-21 run created `bara.standup.2026-W43`, opened that day's entry in it and patched the index, leaving the two misfiled entries in place. Whether the other four stand-up documents and `bara.owner-session-agenda` carry the same gap was **not checked** — APP-2513.)

  **A new dated entry is written with `prepend`, never `append` (`APP-2896`).** The paragraph above says each working-day entry is *appended* to that ISO week's child, while `convention-decision-log`, whose bucketing shape this one borrows, says a child holds its entries **newest entry at the top** — append-the-verb against newest-first-the-order, in one instruction. A run that follows the verb lands the day's entry at the bottom of the child, below the index paragraph and beneath yesterday's, and inverts the order for one day while erring in the direction canon's own wording points, which is why the fault reads as compliance rather than as a slip. So **the verb is fixed to the order** and not the reverse: a new dated entry is written with `prepend`, and `append` stays the op for the index's archive row and for anything whose place genuinely is the end of the document. A misordered historical entry is **left where it is and named**, never moved — `convention-linear`'s document-safety rules make a hand-cut of filed content the more expensive error, the same reasoning that leaves the misfiled entries of the rollover rule above in place. **Whether `prepend` on a Linear document lands at the top is unverified**: `convention-linear` records that only `append` has been exercised on a document's `patch` there, and `APP-2896`'s account of a `prepend` landing correctly on 2026-11-05 is that run's **report**, not an observation of this pass — the probe is the `prepend` result read back on the next stand-up write, per the write-echo rule. (Worked case, **reported**: `apps.standup.2026-W45` held its 2026-11-04 entry below the instructions paragraph and beneath 2026-11-03, found by the 2026-11-05 run reading the document before drafting; that run restored the order with `prepend` and left the stray entry where it sat. Whether the other four `<vertical>.standup.YYYY-Www` documents share the misordering was **not checked** — `APP-2896`, the same make-the-slip-impossible shape as `APP-1326` and `APP-2166`.)
- **Weekly — the strategic Owner session (managing up).** Once a week the operator runs the full loop above and prepares the strategic agenda for the Owner (step 8) — goals and progression, strategy input, concerns, and the mandate-edge escalations — booked into `work.Operators` via Aide. **The loop runs about one hour before its own session, on the same day** (Owner ruling, Aled, 2026-09-22, APP-1657). The D-1 rota is **retired**: a loop no longer runs the day before the session it feeds. The **session rota is unchanged** — Mon Mr Pritchard · Tue A1 · Wed Apps · Thu bot.Trader · **Fri BARA** — and each vertical's loop now fires on that same day, roughly an hour ahead of the slot: Mon Mr Pritchard (loop Mon) · Tue A1 (loop Tue) · Wed Apps (loop Wed) · Thu bot.Trader (loop Thu) · **Fri BARA (loop Fri 12:15, the pattern the other four now copy)**. The stale-agenda problem is **dissolved, not absorbed**: Mr Pritchard's Monday session no longer carries a three-day-old agenda, because the loop that produces it ran the same morning, so nothing has to absorb the gap and the mechanisms that used to — the morning confirm-or-reduce and the 10-minute floor — are retired rather than relied on (superseding Owner rulings 1, 2, 4 and 5, 2026-08-17, APP-852). **APP-1572**'s request to move the Mr Pritchard loop to Friday is superseded by this ruling and is not actioned. **BARA proved the same-day pattern that is now the general rule**, ruled by the Owner on 2026-09-11 for BARA alone and generalised to all five verticals on 2026-09-22 (APP-1657): the loop fires **Friday 12:15** and the session sits in that same afternoon's `work.Operators` occurrence, so the agenda it produces is hours old rather than a day — the correction to a Monday slot that left the standing agenda three weeks stale (APP-1351). The Owner has since ruled otherwise: same-day is **the rule for all five verticals**, not a BARA-only exception, and BARA's shape is the one the other four copy (Aled, 2026-09-22, APP-1657). Two consequences follow for Aide, and neither argues against the same-day rule: the session itself needs no same-day booking, because `work.Operators` is a standing window the Owner declared and each day's session occupies its own occurrence, and **the window runs Mon, Thu and Fri only — not Mon–Fri**, which is the form this sentence carried until this run and which is wrong: `convention-hold-windows` holds the window table and is the single holder of each window's cadence, so this file expresses the session **rota** and never restates the window's days (**observed** this run on the live series' own recurrence rule, `FREQ=WEEKLY;WKST=SU;BYDAY=FR,MO,TH` — three days, not five — against the Mon–Fri shape this file had **reported**; a loop that resolves a Tuesday or Wednesday session against a five-day window resolves it against an occurrence that does not exist, and two canon files disagreeing about the same window is worse than either being wrong on its own, because each reads as authoritative on its own page); but any **new** block a same-day loop asks for — a sizing, an unblock slot — reaches Aide on her next end-of-day pass and therefore lands *after* the session, so a same-day loop asks for next week's slots, not today's. The Aide daily loader fires at **end of day** (17:00, weekdays), which is exactly why a same-day loop's **new** block requests land after the session and must therefore ask for next week's slots; APP-985's config action is discharged, and the D-1 timing it was originally configured for is retired with the rota (APP-1657).

The daily shadow-standup keeps the vertical moving without waiting for the weekly; the weekly session is where the Owner steers. Both are the same loop at different altitude, not two behaviours.

**The gate cadence (APP-869).** Delivery and lifecycle gate verdicts — a merge approval, a Path A promote/retire, a design sign-off — are ruled **async in Linear or at the daily stand-up**, not saved up for the weekly session. The **weekly Owner session is initiative-level only**: strategy, goals, resources and targets. A genuinely critical item is flagged **Urgent and pushed** to the Owner immediately (per `convention-linear`'s age-and-priority ladder), never held a week for the session to catch it.

## Escalating an Owner-blocked stack — by consequence, not repetition (APP-687)

When a vertical's critical path sits blocked on the Owner, the loop's strongest move is **not** a stronger adjective on the same weekly report — that recursion (re-report at constant volume, or, worse under the daily cadence, re-state the same ask every 24 hours) is the failure this section closes. Three rules govern what the loop does instead:

- **Rank by consequence alongside age, not age alone.** `convention-linear`'s escalation ladder climbs on **age**; that is necessary but not sufficient when the waiting items differ in what a day's delay costs. An ask whose delay is **irreversible** — ground truth that cannot be refetched, a window that closes, data permanently lost — outranks a same-aged **reversible** judgement (a merge call, a sign-off) and is flagged **Urgent regardless of the number of days waited**. Age breaks ties within a consequence tier; it does not order across tiers.
- **One consolidated daily gate block, worst-consequence first.** Rather than N items each climbing their own age ladder and each re-stated on their own clock, the daily shadow stand-up emits **one** dated block — *"N items are waiting on you; here is each question in one line"* — ordered **worst-consequence first**, then by age. The gate cadence already makes the daily stand-up the home for delivery and lifecycle verdicts, so this extends a rule already written; it is the forcing function the weekly loop structurally cannot provide, and the direct remedy for a report that was ~90% identical week on week.
- **Escalate, never repeat.** An item already raised is **escalated, not re-sent**: bump the priority and, where warranted, the state — **never re-post the same comment** (`convention-linear`, *escalating a stalled decision item — by age, not repetition*). An Owner-blocked critical path is raised into the **daily stand-up and the weekly check-in**, not re-sent as a duplicate standing report.

**A rescoped item is a standing recommendation, not a re-nag (APP-866).** Where an overdue item's date is already under an open rescope / re-date decision, the operator loop carries the **standing recommendation to resolve that decision** (with the decision's own age), rather than re-flagging the raw lapse each cycle; the daily brief carries the rescope pointer once then falls silent (`task-daily-report`, *Overdue under an open rescope*). *(Escalation-ownership split flagged for Owner confirmation — recommended: the brief points once, the operator owns the standing recommendation.)*

**And the standing recommendation carries its own date, which can itself lapse (APP-2419).** The rule above tracks the **decision's** age and never the **proposal's** own target date, so a re-date that is proposed and not enacted becomes a second staleness sheltering under the first rule's cover: the raw lapse is correctly not re-flagged, and the thing that was supposed to resolve it is not tested at all. The mechanism is what makes it invisible — **the proposed date is comment-resident, in no date field at all**, so a field-keyed overdue read cannot see it and the age-keyed read above does not test it. So where the standing recommendation names a target date, that date is compared against today on every pass that carries the recommendation, and a **lapsed and unenacted** recommendation is re-raised on its own terms — flagged for the next weekly agenda refresh with **both dates named**, the original lapse and the lapsed proposal, and escalated if it recurs — rather than treated as live cover indefinitely. `convention-linear`'s escalation ladder already carries the expiry test for the adjacent case, *"Where the stated hold has expired or its condition has been met"*, so this brings the overdue limb into line with the ladder's hold limb rather than inventing a test; the rule being extended is this file's, not `convention-linear`'s. (Worked case: APP-612 has carried dueDate 2026-09-30 since filing; `apps.owner-session-agenda` proposed re-dating it to 2026-10-16; that date passed three days before the 2026-10-19 `apps.standup` pass, which correctly declined to re-nag the 2026-09-30 lapse on this rule's authority and so carried the lapsed proposal silently for three days running. APP-612's live dueDate and the comment carrying the proposal were **not re-read** by the pass that authored this change — APP-2419.)

## Guardrails

* **Autonomous within mandate, escalate at its edge.** Tactical and day-to-day choices are the operator's; only the three anchors and the human-faculties and authority categories go to the Owner, always with a recommendation, never actioned unilaterally; everything inside the positive grant (step 5) is decided here and logged.

* **Judged on composition, not on going quiet.** The measure of this loop's escalation behaviour is the share of *new* forwards reaching the Owner that sit in the human-faculties and authority categories — it should climb toward all of them; a strategic-context, how-and-where or prioritisation item arriving is an over-forward or a taxonomy defect, visible on the message because the forward names its category and failed test. Volume falling is only a supporting signal — a fall with poor composition means the operator went silent, not that it took the load. **One ruling later found to have been irreversible is the alarm**: it reopens the grant itself in the weekly session, not just the call. Both numbers derive from the forward format; nothing new is instrumented, and the baseline is forward-only from 2026-09-03 (APP-962).
* **Thin, not a duplicate.** Compose Atlas and Relay; never re-implement planning or delivery-flow inside the loop.
* **Does not self-gate delivery.** The operating loop decides *what* to pursue; it does not replace Prism's review or the merge gate. Driving its own session (step 4) changes who spawns the legs, not who gates them: Prism still reviews in isolation, Relay still merges, and the operator does neither.
* **Read the real state, not just the real numbers.** Assess against the vertical's live analytics and KPI sources, never assumed figures — no fabrication (`convention-ticket`). The same holds for *state*: any claim in a status update, a KPI row or an Owner recommendation that asserts the state of a live artefact — what is published, what a page shows, what an integration is doing — is read from the artefact through the connector, never inherited from a ticket body, a previous status update, or an earlier run's own report. A ticket body is evidence of what was true when it was written. The read is the cheapest sufficient one — one connector call, not an audit of the venture each loop. A functional agent reads the artefact because its job is to change it, so the fleet's picture is routinely fresher than the operator's while the operator writes the reports; that asymmetry is why the correction arrives via the fleet, late, after the claim has reached the Owner. (Worked case: BARA reported "three of eight sellable pages cannot be sold — the bundles are live with empty descriptions", inherited from MBN-250's body, across two initiative updates, a project update and the Owner agenda over 2026-08-10 → 08-17; all five bundles were draft and always had been; one `search_products` call would have settled it; Objective 1's second KPI read "5 of 8" when it was met on its own wording. A confident, well-formatted decision item costs more unverified than the same claim in prose — APP-994.)
* **A rate is read over its population, not only its value.** The guardrail above tests a figure's **provenance** — did it come from the artefact or from a ticket body. It has no test for its **population**, and a live, correctly-read, well-formatted rate over the wrong denominator is indistinguishable in a status update from a sound one, and more persuasive than prose because it carries a number. A rate is self-concealing that way: the only signal that 302 sessions was not 302 shoppers is a second query nobody was told to run. So where a KPI this loop reports is a **rate**, the run states the **denominator's composition** at least once per cycle, at whatever granularity decides **addressability** — geography where the vertical sells into one market, bot against human where traffic is organic, paid against organic where the channel is the question. One extra grouped query, the same order of cost as the reads this guardrail already mandates. A KPI table carrying a rate shows **raw and addressable side by side, each labelled**, so neither can be read as the other. And **a metric moving in the right direction is re-based before it is reported as good news** — a rise reported approvingly is precisely the case in which nobody asks what the base is doing. (Worked case, reported by `task-bara-operator-loop` on 2026-09-25 and **not verifiable from a canon drain's surface**, which reaches no analytics platform or storefront: six consecutive BARA operating loops read sitewide conversion, sessions and cart additions live from the storefront and obeyed the guardrail above exactly. Every read was correct. Every one was also over a denominator in which roughly six sessions in seven were out-of-market, against a store that ships to one country, and the session growth reported approvingly across those six loops was that out-of-market spike. "0.0% conversion" drove a navigation rewrite, a collections purge, a trust-page programme and finally a checkout hypothesis that held the top of the board for 39 days; the constraint was demand throughout, and the correction arrived only because an unrelated test order forced a look at *who* the sessions were, which no rule required. This is APP-994 one level down — that note is unverified *state*, this is verified state over an unexamined *base* — APP-1769.)
* **A figure is read over its window, not only its aggregate.** The two guardrails above test a figure's **provenance** — did it come from the artefact or from a ticket body — and its **population** — what the denominator is actually made of. Neither tests its **window**. A correctly-read, correctly-populated rate taken over a long trailing window cannot distinguish **declining** from **stopped**, because a tail of zeros is averaged into a figure that still reads as a number; and the longer the stop runs the more of the window is zeros, so the aggregate keeps falling smoothly and keeps reading as drift, which is the failure getting quieter as it gets worse. So where a KPI this loop reports is a **trend or a change**, the run reads the **daily (or finest available) series inside the window as well as the aggregate**, and **says which it read**. Where the series has gone to zero and stayed there, the report says **stopped, with the date it stopped** — never a percentage decline, which is the shape that hides it. Keyed on the **window, not on the direction**: a monthly figure rising on a one-day spike that has already ended fails the same test, and a rise reported approvingly is precisely the case in which nobody asks what the latest days are doing. Seven days at least, not "since the last loop" — a weekly loop that reads only since its predecessor cannot see a stretch straddling two runs, and the operator loops do not all fire reliably (`APP-1433`). One extra `TIMESERIES day` query per headline measure, on a read the loop already makes: the same cheap test in a third dimension — **provenance, population, window** — so state the window alongside the figure, exactly as the population rule requires the denominator to be stated. A zero is a different class of event from a low number, as a cycle closing with zero completions already is (`APP-1813`), and it earns a decision rather than a sentence. (Worked case, reported by `task-bara-operator-loop` on 2026-10-09 and **not re-read from a canon drain's surface**, which reaches no analytics platform or storefront: the BARA read gave **UK 38 → 33 sessions over a 30-day window** while the daily series inside that window had been **zero for seven consecutive days**, raw traffic continuing on the same days, so the segment had stopped rather than the measurement. The aggregate was correct and the conclusion — "addressable traffic unchanged" — was wrong; the October conversion gate it bore on was already arithmetically unreachable with 22 days left, and the run looked at the daily series only by accident, while checking whether the previous week's reported rise was real. — APP-2214.)
* **A trend is read against a commensurable base, not only against the previous figure.** The three guardrails above test a figure's **provenance** — did it come from the artefact or from a ticket body — its **population** — what the denominator is actually made of — and its **window** — what the series inside it did. None of the three tests **commensurability**. The population rule is satisfied by *stating* the denominator's composition once per cycle, and the window rule keys on the reported figure's own series rather than on its base, so neither compares this cycle's composition against the last one's: a trend column can span two different populations and still read as a trend in the measured thing, which is the failure the first three leave standing after each has been obeyed exactly. So where a run reports a figure as a **trend or a change against a previous cycle's read**, it compares the denominator's composition against the composition the previous cycle stated, and where that composition has shifted materially it **says so and reports the comparison on the stable sub-population**, not on the raw aggregate. **A segment leaving the denominator is named as its own event, with its date** — on the same footing as a zero (`APP-2214`) and as a cycle closing with zero completions (`APP-1813`), never absorbed into a percentage, which is the shape that turns a change in who is counted into an apparent decline in what is measured. And where a non-addressable segment holds the **majority** of the denominator, the **addressable series is the headline trend** and raw is the secondary line: the existing raw-and-addressable-side-by-side rule (`APP-1769`) makes the table honest about which is which, it does not decide which number leads, so a table can be fully compliant and still lead with the number nobody can act on. The cost is **one comparison against the previous status update, and no new query** — the composition is already stated there by the population rule, so this guardrail spends a read of last cycle's own line. (Worked case, reported by `task-bara-operator-loop` and **not verifiable from a canon drain's surface**, which reaches no analytics platform or storefront: BARA reported raw sessions **371 → 338 → 303 → 213** over four weeks and read it as a third consecutive weekly decline, while roughly **86%** of that base was a single crawler run that had stopped — so the two ends of the trend were two different populations. The stable comparison ran **UK 31 → 38 → 33 → 25** throughout and was never the headline; the crawler's departure was an event with a date, and it was reported as a percentage — APP-2403.)
* **A measure is read over a surface that can observe the act, not only over a correct base.** The four guardrails above test a figure's **provenance** — did it come from the artefact or from a ticket body — its **population** — what the denominator is actually made of — its **window** — what the series inside it did — and its **commensurability** — whether this cycle's base is the same population as the last one's. All four test the **number**; none tests the **instrument**. A measure computed from one surface cannot distinguish **"not done"** from **"not observed"**, and the failure runs one way: an act nobody could see reads as an act nobody performed, so the figure fails silently in the direction of **false pessimism** — the loop then diagnoses the wrong constraint, and the remedy it reaches for is orthogonal to the cause. It is also self-reinforcing in a way the other four are not: a zero on a committed act reads as diligence — the miss is named, the ticket is closed unmet, the floor is held — so the discipline that makes the reporting good is what makes the error durable. So **before a figure of record is reported, the run names the surface that can observe the act being counted** — the artefact, the connector, the log, or the human who sets the state — stated once per cycle at the point the measure is defined rather than recomputed each run, so it costs no new query. **Where the counting surface cannot observe the act, the figure is reported as unobserved rather than as zero, and the run names what would observe it.** **And observability is not binary.** Where a cheap existing instrument *partially* observes the act, the run says what that instrument can and cannot see rather than calling the act unobserved outright, and it reports that partial reading **alongside** the recording remedy, never instead of it: a partial instrument narrows the question and still leaves the act unrecorded, so it is evidence and never the fix. (Worked case, **reported** by the filing leg and not re-read here, no storefront connector being exercised on the refine surface: a storefront sessions-by-referrer read showed inbound sessions attributable to a channel on one day against a seven-day zero baseline, while seeing nothing of whether any specific post went live — the channel was partly observable and the act was not, and the recording remedy stands unchanged. `APP-2922`.) A zero on an unobservable act is named *not observed*, never *not done*: the two have opposite remedies and the measure cannot tell them apart, which is why this is a test of the instrument and not a fifth test of the number. (Worked case, reported by `task-mrp-operator-loop` on 2026-10-19 and **not re-read from a canon drain's surface**, which reaches no LinkedIn surface: Mr P's standing weekly target — 1 post, 3 comments, 1 reshare — is computed entirely from Linear ticket states; nothing closes the post ticket when the Owner publishes outside it, and the fleet holds no LinkedIn connector. W41 and W42 both closed **0 of 1** post and four consecutive weekly reports led on a version of *nothing has been published*, while two Owner-attributed comments on the same board — MRP-72 and MRP-24, both 2026-10-14 — say a post went out. Provenance, population, window and commensurability each passed exactly, and the figure was still wrong. **Whether a post actually went live is unverified from any surface this run reaches**, and the rule does not depend on it; the recording remedy is the vertical's own and needs no connector and no credential (MRP-88). The BARA, A1 and bot.Trader instances of the same shape were **not checked**, and this is not a claim that they are affected — APP-2438.)
* **A fact claim about an event outside the tracker is read over the surface that names its particulars, not over the surface whose evidence is a ticket field.** The five guardrails above test a **figure** — its provenance, its population, its window, its commensurability, and the instrument that produced it. None of them governs a **fact claim about an event outside the tracker** — a meeting, a send, a conversation — where two surfaces disagree about whether it happened. The rule: **the surface that names the fact's own particulars outranks the one whose evidence is a ticket field.** Particulars means time, place and participants for a meeting, or a delivery timestamp and recipients for a send — **and the obligation, not only the occasion.** A surface discharges a ticket only where it names **what was covered, against that ticket's own scope**. A document that is fully specific about an event and silent on which obligation the event discharged has named the occasion and not the particulars: the conflict is **unresolved on particulars**, and the escalation limb below applies rather than the resolve-and-report limb. *"It discharged X in the same slot"* is a claim about **scope**, not about time, place or participants, and a test that reaches only the latter three can be satisfied in full by a surface that is wrong about which obligation was met — one meeting in a diary, several tickets pointed at it, and a debrief that collapses them is a common shape, not an edge case. **And a participant's own word outranks any document about whether his own conversation happened.** Where the conflict is over an obligation a named person holds — his meeting, his call, his decision — no third-party surface outranks that person's own statement, however complete its particulars; the provenance rule ranks a document against another *document*, never against the participant. The two compose: the first is the general test, the second settles the case the first is most often run on. **Recency does not decide it** — the newest of three assertions may be a restatement of something else entirely. And a **state read cannot settle it in either direction**: the `APP-1976` rule in step 5's thread-reading guard says a state read agreeing with a claim is not corroboration of it, so a state read **disagreeing** with a claim is not refutation of it either — a `Todo` field is evidence about the tracker, not about the world. **A surface meeting this conflict resolves it on provenance and reports the resolution**, rather than stopping at *"needs your word on which it was"* and handing up a question nobody can answer from the two surfaces in front of them. **The one exception is where the resolution's own consequence is a call rather than a clean-up**, which is where it escalates with a recommendation instead — and that is a bound on the **act**, not an exit from the rule: the resolution is still stated, and what goes up is the thing it would release. (Worked case, **reported** by `task-a1-operator-loop` on 2026-10-20 at 11:3xZ and **not re-read from a canon drain's surface**: A1-718, derived from `a1.cycle-goal.2026-W43` — Owner-authored, Owner-committed 08:56Z, naming the session as Friday 2026-10-16 10:30–11:00 at 33 Queen St Pl with its organiser, all three attendees, who accepted and when, and four substantive outcomes from it — asserted four tickets discharged. A1-696 carried a same-morning 06:39Z sweep comment asserting the Ann conversation was **not** yet held, and its only evidence was A1-696's own `Todo` state. The document won on particulars. The loop closed A1-617, A1-624 and A1-629 on its record and **held** A1-696, because closing it releases A1-543, a purchase the Owner has paused twice — a call, not a clean-up — and escalated it with a recommendation as item 1 of `a1.owner-session-agenda`. The newest of the three assertions, an 18:10Z comment on A1-543, is a restatement of the 10-14 pause and not a finding about the meeting at all, which is the counterexample to deciding on recency. And one practical fact neither conflicting surface held: a live `Ann x Aled` slot moved to 2026-10-21 16:00–16:30 and unaccepted, so even the *not yet held* reading had a resolution date — both surfaces were reading Linear only. `APP-2478`.) **That worked case is corrected, and the correction is the reason for the clause above:** the Owner reversed the resolution the next day — *"The chat has not been held. Ann declined the 21 Oct 16:00 slot, and Aled will liaise with her directly to re-arrange it. The ticket stays open"* (**reported** wording, 2026-10-21, not re-read from a canon drain's surface), and his own call note of 2026-10-26 21:10Z records *"(The 21 Oct call did not happen. This is the first.)"*. **Observed** on 2026-10-27: A1-696 is `Todo`, `statusType: unstarted`, so live state still contradicts the worked case's conclusion. The document's particulars were true and complete and about a **different** conversation — a 10:30–11:00 session with Ann, Ash and Aled at 33 Queen St Pl did happen; what did not happen is the one-to-one commitment check A1-696 scopes. So the worked case is read as the **failure** of the occasion-only test, not as its demonstration: the three closures it supports stand on their own records, the holding of A1-696 stands and is the exception limb working correctly, and the resolution it reported about A1-696 is withdrawn. `APP-2478`'s own conclusion is wrong on the facts and should be re-read alongside this. (`APP-2712`.)
* **Report at the ruled altitude.** The daily signal is per-project and written by `task-daily-report`; the weekly headline is the operator's, on the vertical's own initiative, in the standing format (APP-998); target dates and KPI baselines are the Owner's, proposed by the operator and confirmed in the weekly session (`convention-project-status`).
* **Don't re-report; escalate by consequence.** A second same-window run emits the delta, not a duplicate; an Owner-blocked stack is ranked by consequence-alongside-age and consolidated into one daily gate block, never re-sent (APP-687, APP-884).
* **Re-read before restating.** An item carried from a previous entry is re-verified against the live board in the run that restates it, and the restatement names the state it read and the time it read it. An item that has closed, been cancelled or been re-routed since is closed out in one line, not carried forward (APP-1477).
* **A standing prose claim is re-read on the refresh that restates it, and a third restatement is not available.** The rule above covers a **board item** — something with a state to re-read. It does not reach the prose a standing agenda carries *about a capability*: a *Standing gaps* line, a "not live", a "no path onto the calendar". Neither does step 8's second-week re-grounding, which is scoped to *Open — decisions for the session*; nor step 8's missed-refresh guard (APP-1536), which fires only when a window was missed. An agenda refreshed every week on schedule passes all three, and **being current is exactly what lets a stale sentence ride**. So every prose claim a standing agenda or a carried stand-up entry makes that **cites a ticket, an artefact, a scheduled task or a capability — or a metric, a series, or a count or streak derived from one** is re-read on the refresh that restates it, and the line names what it read and when, in the same `read HH:MMZ` form already required of restated board items (APP-1477). **But a per-line stamp is self-asserted, so a standing list of ticket-citing lines is checked as a set, against a read that could have falsified it.** Before the prose is written, the refresh takes the `list_issues(label: "operator-<venture>")` read it already runs under *The read recipe* above (APP-1011) — with `statusType` in `fields` — and drops every line whose ticket comes back `completed` or `canceled`. The list then carries **one** claim: the read it was checked against, the time that read ran, and how many lines were dropped as closed. **That single claim is stated once, in place of n per-line stamps**, because n stamps over n unseen reads are not falsifiable and one claim over one named read is. A stamp can be written from the previous line, from a stale cached result, or from a read whose result was never applied to the prose beneath it, and the surface cannot tell those three apart — a timestamp looks like evidence for the same reason an incrementing counter does, and it is cheaper to write. Per-line stamps may stay as colour beneath the set claim; they are never the evidence for it. The check is written over *any* standing list of ticket-citing prose lines — a standing agenda's Async section, a carried stand-up entry — not over one named list, since they are the same shape. (Worked case, **reported** by `task-a1-operator-loop` and not re-read from a canon drain's surface: `a1.owner-session-agenda` as refreshed 2026-10-20 carried A1-330 and A1-622 in *Async — not for the session*, each with its own `read 11:2xZ` stamp, one of them framed as "a one-word close" the Owner still needed to make; a 12:35Z label read on 2026-10-27 returned both `completed`, neither state new, so both rode the list to the Owner as live items for a week. A1-337 on the same list was stated at "83 days open" against a 2026-08-13 creation date — 68 days at that refresh. Being current and stamped is what let it through: APP-1477's re-read rule is satisfied by any state read, APP-1536's missed-refresh guard does not fire on an agenda refreshed on schedule, and APP-2537's ruled-but-unenacted result is about a newer ruling on a thread, not a closed ticket. This is APP-2398's shape and APP-1977's argument — completion claimed only on a read that could have falsified it — on a timestamp rather than on a counter — APP-2713.) And a count or streak restated across entries is **re-derived from a fresh same-metric query on the entry that restates it, never incremented from the previous entry's number** — the discipline the carried-item rule above and the queue-count rule already apply to ticket populations and ticket ages, extended to a series. The restatement names the query, its scope and the time it ran, in the same `read HH:MMZ` form this bullet already requires. The asymmetry is what makes it bite: an incrementing counter *looks* like evidence of a fresh read — the number moved, so something must have been checked — and it is the one restatement shape that grows more confident as it gets less checked, so the longer it runs unchecked the more weight it is given. (Worked case: *"UK sessions zero every day since 2026-10-02"* was restated and incremented across four `bara.standup` entries to *"13 consecutive days"* and carried verbatim into the Owner's agenda as the stated basis for a gate-threshold recommendation; a fresh timeseries read on 2026-10-16 showed one session on 09 October and one on 15 October, both inside the claimed streak. One edit covers both hops of that propagation, because this bullet is already written over *"a standing agenda or a carried stand-up entry"* — the Owner-agenda twin needs no second rule, and the stand-up loaders are thin and inherit this file — APP-2398.) And the repeat counter is a **trigger, not a decoration**: a standing gap reaching its **third** consecutive refresh is converted — into a ticket, or into an escalation carrying a recommendation — or it is dropped. A line nobody is acting on is the population the standing "an observation repeated across runs without an owner becomes work or stops being reported" rule already targets; writing "fifth consecutive refresh reporting this" into the line itself as evidence of diligence is that rule's own trigger being used as ornament. (Worked case: `bara.owner-session-agenda` carried *"Aide's runner is not live (APP-428), so no operator's agenda has a path onto the calendar and this leg cannot confirm today's slot"* across **six consecutive refreshes**, four initiative status updates repeated it, and the daily stand-up inherited it verbatim. Verified against Linear: APP-428 is `Done`, `completedAt` **2026-08-14T11:18:19.719Z** — closed before five of the six reports that cited it as open. Aide's daily and weekly loaders were reported enabled and succeeding and the session was reported on the calendar, both from surfaces a canon drain cannot read. A working capability was reported as broken, weekly, for over a month, to the person who owns it — APP-1768.)
* **Propose the budget, do not spend beyond it.** The envelope is whatever `<vertical>.mandate` says today. Where it is zero or too small, produce a costed proposal for the Owner; act on free/existing fleet resource until an envelope is granted, and never write the figure into the profile.
* **Scope.** One vertical per run, the operator's own; cross-vertical contention for the shared fleet is Atlas's to arbitrate, not this loop's.
* **The human-lane census is derived from the executor label, re-run every loop.** What sits in the Owner's lane is the set of tickets carrying the `human` executor value, not the set assigned to him — the assignee field is set by many hands and reads wrong (MBN-263, found 2026-08-22). A ticket that is only partly human is split into a `human` leaf and a fleet leaf (`convention-ticket`'s credential-gated split), never carried `human` wholesale (MBN-256, MBN-254 — APP-1064).
* **Tracker hygiene inside the vertical is the operator's, never an Owner item.** Grouping the vertical's projects under its initiative, fixing labels, adding relations — one click with no goalpost effect. **Project status is not on that list.** A project's `status` is the field every liveness-scoped sweep gates on — `task-daily-report`, `skill-coordinate`, `skill-fleet-dispatch` — so writing it reroutes what several artefacts look at, which is the opposite of a click with no goalpost effect. `convention-project-status` already rules the correction a **major-level proposal**, surfaced by `skill-plan`'s weekly pass and never auto-written, and that holds for an operator that finds the same mismatch inside its own vertical: surface it with the proposed status and the evidence, and leave the write. **Reversibility is not the test here** — the write is trivially reversible and still changes what four other artefacts see, silently, from the moment it lands. The guardrail stands and nothing here widens it: the canon-decisions ruling of 2026-10-20 declined the narrow `inactive → started` operator grant in terms — "Operators are not granted status write" — as reported on `APP-2362`, the provenance **unverified** because the connector stamps every comment on this workspace as the Owner's and no transcript is readable from that surface (`APP-2279`). **And an Owner-approved cycle-goal document does not widen a standing grant either.** Where a `<team>.cycle-goal` document instructs a status write — `mrp.cycle-goal.2026-W41`'s directive 3 did, on the very team whose worked case set this bullet — this guardrail governs and the operator **surfaces rather than writes**, because a grant change moves through the Pulse queue like any other canon change and an approved cycle goal is not that queue (`APP-2045`). **What changes is the consequence of leaving the field unwritten, not the permission to write it.** `skill-portfolio-allocation` **Pass 1** no longer reads an inactive status as a deliberate denial: where a project's status reads `Backlog` while it holds an unblocked started-or-unstarted ticket, Pass 1 reports the bet as **status-inconsistent** and allocates on that demonstrated readiness, proposing the correction in parallel. So surfacing no longer starves the work, and the two clauses can no longer compose into a standing denial of capacity that neither states — the deadlock that cost two ready Apps bets their whole allocation at the W40, W41 and W42 boundaries (`APP-2362`, folding `APP-2045`). (Worked case: the 2026-10-01 `mrp.standup` run found Mr Pritchard's **Operations** project carrying a `backlog` status while holding most of the vertical's live `human`-lane work, named the mismatch correctly, and then set it to **In Progress** itself under this bullet's grant — stamping a `startDate` of 2026-10-01 on a project created 2026-06-02 — APP-1936.) Grouping `mbn.brand` and `mbn.website` under the BARA relaunch initiative sat in the Owner's lane for three loops (APP-1064); it should have taken the operator a minute.

## Setup

Deployed per vertical as a thin `task-*` weekly loader (`task-bara-operator-loop` is the first). The loader supplies the operator context and reads-and-follows this skill; behaviour lives here, not in the loader. The operator profile names its mandate document and its State sources; it never states the mandate's figures, so a change of envelope or window is an Owner edit to the document and needs no canon change. On finish, run `skill-ops-retro` capture on this run's friction: file a `FRICTION:` note to the Pulse queue for the drain to assess.
