---
name: "task-cycle-planning"
type: task
description: The cycle-boundary ceremony, run as a scheduled task — retro the closing cycle, roll over incomplete work, and propose the next cycle's commit and its one goal, with Aled the gate on cycle membership and goal. Owned by Atlas, propose-only, Linear connector, delivery teams only (Apps, A1, MBN, Mr Pritchard). This is the self-contained process — there is no separate cycle-review skill, because the ceremony is a job you run, not a craft invoked ad hoc; its Layer 4 path is workflow-cycle-planning. Run it at a cycle boundary, or on demand to review a closing cycle and plan the next. Sized against observed throughput, not a full board; skill-plan (the weekly focus snapshot) is a sibling and is never edited here.
license: CC BY-NC-SA 4.0
---

You are running the **cycle-boundary ceremony** for Aled's delivery teams, on Atlas's behalf. At the boundary between one cycle and the next you retro the closing cycle, roll over what did not finish, and propose the commit for the cycle that is opening. This is the process itself — self-contained, not a loader over a skill. Its standing Layer 4 path is `workflow-cycle-planning`; the owning role is `agent-atlas`. Follow `convention-linear` and `core-operating-model` throughout.

**Write scope — what you may and may not change.** You **read** cycles, milestones, the board and the `[goal-review]` output; the only thing you **write** is the commit proposal, posted as a comment for Aled — and, once a cycle has closed, the close of that cycle's `planning-week` record (Step 1, *The planning-week record*). You **never write cycle membership** — no add, remove, or move — in the scheduled, unattended ceremony. The membership write happens only after Aled's explicit approval, in the session where he gives it and on his instruction, carrying the approval marker (Step 4, *The membership write — in session, on the Owner's instruction*; APP-1580, 2026-09-21). You never mark Done, never cancel or defer a ticket autonomously (those are major moves, surfaced for Aled), never write code, and never touch the Pipeline team. Connector: Linear only. Teams: **every delivery team that runs cycles, resolved live from** `convention-linear`**'s team table — Apps, A1, MBN and Mr Pritchard** — and no others (never Pipeline). **Where this list and that table disagree, the table wins**, and a team that has an active cycle but appears in neither is reported rather than skipped. A hardcoded three was wrong in the direction that hides a whole team: Mr Pritchard runs cycles on the same Sunday boundary as the other three (verified 2026-09-12: cycle 10, 2026-09-06T23:00Z → 2026-09-13T23:00Z), and every downstream approval test is specified against `<team>.cycle-goal.YYYY-Www` for *each* delivery team — `skill-attention-sweep`'s freshness read names Apps, MBN, A1 **and Mr Pritchard** explicitly. So a ceremony scoped to three teams leaves Aide permanently unable to satisfy the test for the fourth: no goal document is ever created for it, the freshness read fails every boundary, and the failure reads downstream as *nothing to do* rather than as *never committed*. This is the APP-521 / APP-550 shape — a scope list that predates or under-reads the team set misses a whole team's work silently — applied to the ceremony that produces the artefact everything else tests. (APP-1383.)

## Step 0 — Resolve the boundary, per team

For each delivery team, **confirm it has an active cycle, then resolve that cycle by UUID** — call `list_cycles(teamId, type:"current")` to get the cycle object, its real UUID and its dates. **Never pass the literal `"current"`** to `list_issues`' `cycle` param: it silently returns zero for every team, with no error, and a run that trusted it would report a false negative on a genuinely committed cycle (`APP-580`; `convention-linear`, *Reading Linear safely*). Where a team genuinely has no active cycle (mid-boundary, newly created, cycles disabled), say so once in the summary and skip its cycle-dependent steps rather than no-opping silently.

Identify which teams are **at a boundary** — a team whose **current cycle's `endsAt` falls within about 72 hours of the run** (Owner decision, Aled 2026-09-21, APP-1577; this replaces the 2026-09-03 *previous cycle ended within the run window* test). The scheduled ceremony fires **before** the boundary, on Friday 16:00 Europe/London, so the Owner can approve the commit before the week it governs starts. Linear's Sunday 23:00Z boundary is unchanged: moving it was ruled out, because team settings allow no end time and a hand-edited end date leaves a gap with no `current` cycle. On the Friday run, resolve the **closing** cycle with `list_cycles(teamId, type:"current")` (still live) and the **opening** one with `type:"next"`, both by UUID. **A Friday run reads a cycle still in flight, and that is deliberate.** The retro is partial (Step 1), and the carry-over has not happened yet (Step 2). An on-demand run **after** the boundary keeps the closed-data resolution: closing = `type:"previous"`, opening = `type:"current"`. Do not guess "at a boundary" from the weekday. Resolve it from `endsAt`. The 2026-08-14 run fired 2.5 days early and read a cycle mid-flight by accident, and the 2026-08-17 run read the just-closed cycle by judgement. Both failures came from the same missing definition (APP-1007 / APP-892). The Friday run reads mid-flight on purpose, against a stated horizon. Run Steps 1–4 for each team at a boundary. On a scheduled fire with **no team at a boundary**, report "no boundary at hand" and stop; do not retro a team whose cycle is not ending. An on-demand invocation names its target team(s) and runs regardless of the day.

## Step 1 — Retro the closing cycle

**On the Friday run the retro is partial by definition (APP-1577, 2026-09-21).** Label it *as of Fri 16:00*. Throughput is `completedAt` from the cycle's start to the run time, not to `endsAt`. Completions that land between the run and Sunday's boundary still count in the closing cycle's burn-up, but not in this retro. Say so, and report them in the next Friday's retro under a *late completions of cycle N* line. The carry-over has not happened yet, so the incomplete committed set is the committed tickets still open at run time, read directly from the closing cycle.

For each team with a cycle closing, read the cycle scope and reconcile it against what happened:

- **What was committed** — the cycle's scope: its membership and count at the boundary. Read it two ways and reconcile them. The **committed list** is the one in the closing cycle's goal document (`<team>.cycle-goal.YYYY-Www`, `convention-linear`) — that list is the definition of *planned* (APP-1095). The **membership** is derived per `convention-linear` *Reading Linear safely*: a team-scoped read filtered on `cycleId` client-side, never the `cycle` param, cross-checked against the cycle's `issueCountHistory`. On an on-demand run after the boundary, Linear's built-in carry-over has already moved the incomplete items into the opening cycle, so the closing cycle reads back only its completed and cancelled members: recover the incomplete committed set as *the committed list minus the completions*, and the incomplete unplanned set as the `cycle:unplanned` tickets now sitting in the opening cycle (APP-1007). **Where the enumerated set disagrees with the cycle's own count, proceed with a caveat — never hard-fail.** Report the mismatch on the proposal with the missing IDs where you can name them, and never infer that a ticket is out of the cycle from its absence in a cycle-scoped read (Owner decision, Aled 2026-09-03, APP-890). **On the Friday pre-boundary run, reconcile for snapshot lag before reporting a mismatch at all (APP-2255).** `issueCountHistory` is a daily snapshot series over a cycle still in flight, so on the Friday cadence (APP-1577) it is a day or more short of the run, and a mismatch is **the normal state rather than a signal** — the 2026-10-09 boundary reported one on all four teams and all four were pure lag, reconciling exactly once the same-day completions were set aside (Apps 62 − 8 = 54, A1 49 − 9 = 40, MBN 13 − 2 = 11, Mr Pritchard 18 − 1 Canceled = 17). So take the members whose `completedAt` falls after the last snapshot the series can cover, subtract them from the enumerated count, and compare the adjusted figure: where it closes, report *"reconciles after snapshot-lag adjustment: enumerated N − M same-day completions = history figure"* and raise **no** caveat; and reserve the mismatch caveat, with the missing IDs, for the residue that does not close. **The series carries no timestamps, so the adjustment is derived from the day count rather than read off the data** — verified live 2026-10-12: `list_cycles` returns `issueCountHistory`, `completedIssueCountHistory`, `scopeHistory` and `completedScopeHistory` as bare integer arrays with no dates and no granularity field, so derive the last snapshot's day as the cycle's `startsAt` plus the array's length, and subtract the completions landing after that day. **And an empty array is not a zero:** a cycle early in its life returns all four arrays empty — verified against the Apps team's cycle 14 on 2026-10-12, its first day — which gives the cross-check no basis at all, so report it as *no history to cross-check against yet* and neither reconcile nor caveat. `APP-890`'s caveat-never-hard-fail ruling is unchanged by this; it only stops the caveat firing on arithmetic the run can do itself.

- **Score the goal by its beats, and say/do separately (Owner ruling, Aled 2026-10-19, APP-2400).** The goal's pass condition is a list of numbered beats (Step 3; `skill-operating-loop` step 2). Score each beat met or not met on its own evidence and report `Goal: <beats met>/<beats total> — met | partial | missed | no-commit | zero-commit; stretch: met | not met | none`. *Met* is every beat, *partial* some, *missed* none, *no-commit* a cycle that was never committed (its goal document carries no `Committed by Aled — <date>` line), and *zero-commit* a deliberate commit of nothing. Report **say/do** — committed tickets that reached Done inside the window, over committed — and the **carry-over** count on lines of their own, never folded into the score. The two diverge: A1's W42 met both its beats with 0 of 5 committed tickets Done (`data/planning/a1/2026-W42.json` in `assoc-one/claude-ops`, read on `origin/main` `dc16455`, 2026-10-19).
- **Planned vs unplanned — derived from structure, never from a label (Owner ruling, Aled 2026-10-19, APP-2400; supersedes APP-1788's label route for this measure).** *Planned* is still the committed list in the goal document (APP-1095). *Unplanned goal-serving* work is every ticket **created after the commit's `commit_ts` and before the window closes** that serves the goal by structure: it sits in the goal's project (`basis: project`), is a child of a committed ticket (`child`), or has a blocks, blocked-by or related relation to one (`relation`), taking the first that holds, in that order. The share is `unplanned ÷ (committed + unplanned)`, and it is null where there was no commit or no goal-serving work. Standing-target tickets are planned by construction (Step 3) and are never counted here. **The `cycle:unplanned` count is retired from this retro.** The label has never been applied (APP-1788), and where it was meant to be derived it measured carry-over against a near-empty commit rather than unplanned work (APP-1991). The derivation depends on `commit_ts`, so where the record holds only an upper bound (`commit_ts_upper_bound: true`, as on the backfilled weeks) say so beside the figure. Report **new work** — tickets created in the window that were not committed — as a count beside it. A rising unplanned share across boundaries is a planning signal, not a delivery one; say so where it is rising.
- **Owner dwell — how long goal-critical work sat with the Owner, Owner-lane Todo included (Owner ruling, Aled 2026-10-19, APP-2400).** A ticket is **goal-critical** when it is on the committed list, is derived as unplanned goal-serving work above, or is named as an exception in the goal document. For each goal-critical ticket in the Owner's lane, sum the hours it spent **inside the window** in each of In Review, Refinement, Blocked and **Todo**, and sum its **Backlog** hours as well — reported on a line of their own beside that total rather than folded inside it (**Backlog is the more neglected state, not the less**, so a low Backlog figure is a gap in the measure rather than a good week, and any run reporting the Backlog line states that caveat in the same breath rather than leaving the figure to be read as reassurance. The warrant is an incoherence this artefact already carries against itself: the read-back step below classes **Backlog and Refinement together** as the backlog-type states that a cycle commit force-moves to Todo, while this rule includes Refinement and excludes Backlog, so the measure splits a pair the same artefact treats as one. **Whether Backlog hours belong inside the dwell total is not settled here** — the measure is the Owner's to rule, and this line is deliberately beside the total rather than inside it so that nothing in this edit reads as an answer to it. `APP-2946`), read from the same `get_issue(fields: ["stateHistory"])` call the aged-WIP line makes, never a second read. Record how the ticket was attributed to the Owner as its `basis`: the `human` executor (`label`), the Owner as assignee (`assignee`), a named exception in the goal document (`doc`) or a hand-off comment (`comment`). Todo counts because the state-only measure could not see A1-429, MBN-321 and MRP-70, each 14–35 days in Todo assigned to him. Record **hours**. The trend view reads them as **item-weeks**: hours ÷ 168, so one ticket held for a whole week is one item-week (`scripts/build-planning-dashboard.ts`, `origin/main` `dc16455`; APP-2431). Label history is not in `stateHistory`, so `basis` is read as it stands at the close, and the record's `notes` says so. The daily `owner-queue` block that `task-owner-standup` writes is the captured hand-off event going forward.
- **What took the time — completions and points by project, for now (Owner ruling, Aled 2026-10-19, APP-2400).** From the throughput read above, report the completions in the window, the completed estimate points keyed by project, the share of completions that was canon publishing or `PUL-5E` work, and the share in the goal's project. This is a proxy. Aide's ticket-keyed calendar blocks replace it once they exist.
- **Report membership as three populations, and take the ratio against the committed list alone (APP-2256).** The cycle's membership is not the week's work. Linear's boundary carry-over fills the **opening** cycle with last week's un-closable residue regardless of the commit (APP-1991), and the *Completed issues* automation fills the **closing** cycle with this week's closures at the moment they close (APP-1007) — so a cycle's membership is *(last week's residue)* + *(this week's closures)*, the week's actual in-flight work is in neither, and a ratio taken over the whole membership has much of its numerator sitting in its own denominator. So split the membership three ways and report all three: **committed** — on the goal document's list (APP-1095); **joined-by-completion** — completed, absent from the committed list, with no commit and no membership write behind it; and **carried** — arrived by the boundary carry-over. All three are already derived at this step, so this costs nothing. **State the completion ratio against the committed list only.** Report the other two as volumes and take no ratio over them, and where joined-by-completion is a large share of the membership, say so on the proposal and name it as the reason a raw ratio reads high. (Measured 2026-10-09: A1's cycle 13 read 49 members and 41 completed — 84% — with exactly **one** member in a started state, while roughly thirty A1 tickets were created, worked and in several cases closed outside the cycle that week carrying `cycleId: null`; MBN had six; Apps reads the same mechanism at scale, 47 of 59 in-window completions having joined by closing — APP-1789, APP-1992.) **Never strip a member to fix the figure:** `APP-585` forbids it for a Done ticket and `APP-1991` ruled that stripping carried work hides load rather than sizing it, so the correction is always to the reported figure and never to the board. And turning *Completed issues* off is a **workspace-config lever — named, never filed and never authored by this ceremony**; `convention-linear`'s *Never in a delivery cycle* already sanctions this reading-end fix as the alternative where that automation is wanted for delivery work.
- **What completed — throughput, read from `completedAt` inside the cycle window (APP-891).** Throughput is the count of completions **whose `completedAt` timestamp falls inside the cycle's start–end window**, computed from the issues' own timestamps — not a ratio lifted from Linear's burn-up. `completedIssueCountHistory` (against `issueCountHistory`) is the **burn-up**, which `APP-585` protects by never stripping Done tickets; it is **not** the throughput read. The two are different numbers with different jobs — the burn-up is the cumulative state of scope, throughput is work delivered within the window — and conflating them is the whole defect. The burn-up can open a cycle already high (backfilled with work Done before the window began) and can absorb a bulk close as if it were a week's delivery; neither is throughput. Report the completed count and its ratio, but derive both from `completedAt`-in-window, and treat a cycle that opened with a large already-Done count, or that took a bulk close, as *not read* for throughput until Step 3 separates the batched from the unbatched figure. (Evidence: Apps read 135/167 = 81% with `completedIssueCountHistory` opening at 64 — 62% on day one — and ~64 of ~139 completions landing in an 11-minute drain batch on 10 Aug; MBN read 7/9 = 78% with all nine closed the same day, a dormant team reading as productive. Both are burn-up artefacts, not weekly delivery.)
- **What did not, and why** — the still-open tickets in scope, with a short honest reason each (blocked, deprioritised, oversized, never started, carried in already stale).
- **And a characterisation of a closed ticket carries its thread read (APP-2281).** The line above asks for a reason per still-open ticket. The retro's more expensive claim is about a **closed** one — *cancelled with no reason, abandoned, never delivered, nothing replaced it* — because the state field is the cheap read, it agrees with the claim, and on this shape it is exactly wrong: an approval and a delivery live in the thread and move no field. `skill-operating-loop` binds the symmetric claim on the reporting surface (*a line characterising an item as new, unaddressed or never answered carries its `list_comments` read, read to the end, with its time* — APP-1935, APP-2167); this is that rule reaching the closed side, where the cost is higher, because a false "never delivered" **manufactures** work — it re-commissions delivered output and discards a correct diagnosis. **The rule fires on the tickets this retro names as a cause**, not on every closed member: list them first, read each thread to the end, and carry the read in the line (`MRP-71, thread read to end 11:18Z, delivered and approved 2026-10-06`). On Mr Pritchard it has a standing reading: `Canceled` is the team's only terminal state that makes no publication claim, so a `Canceled` editorial ticket is *decided, not shipped* until its thread says otherwise (`convention-linear`, *A completed-type state on Mr Pritchard is a publication claim*). (Worked case: MRP-71 was commissioned to Reach on 2026-10-05, delivered 2026-10-06 07:09Z, approved by `[operator-mrp]` at 07:30Z — *"its deliverable was the draft-and-review decision, not a publication"* — and closed `Canceled`. Six days later `mrp.cycle-goal.2026-W42` read the state alone, recorded it as cancelled with no reason, and named it the clearest cause of W41's zero: six tickets closed unmet partly on that reading, and a replacement commission (MRP-78) whose first instruction was to recover a reason sitting two comments above the state field, and whose premise inherited the error. Recovered by the `task-mrp-operator-loop` run of 2026-10-12, which read the thread. The ticket identifiers, the timestamps and the document contents are the filing leg's report and are **unverified** here; that flag covers those only, not the canon placement, which was read live — APP-2281.)
- **Aged WIP — how long the open work has sat, not only how much of it there is (APP-1171).** For each incomplete committed ticket, read its **age since its last state change** from `get_issue(fields: ["stateHistory"])`. `get_issue`'s `fields` enum carries `stateHistory`, and its entries carry `startedAt` / `endedAt` per state, so the **open entry** — the one whose `endedAt` is `null` — holds the last state change in its `startedAt`, and the age is the session clock minus that timestamp (read live 2026-10-19 on MBN-288: `In Review`, `startedAt` 2026-09-19T07:10:25Z, `endedAt: null`). **Two neighbouring fields are not this measure and must not be substituted for it.** `updatedAt` is a sweep timestamp rather than movement — one run observed seven board-wide re-stamps in a single day — so it reads a bulk touch as motion and a genuinely parked ticket as fresh; and the issue-level `startedAt` is stamped once, on the first transition into a started-type state, and never re-stamped, so it ages a ticket from when it *first* started rather than from when it *last* moved. **The cost is one `get_issue` per incomplete committed ticket, and it is bounded on both sides:** that is the same per-candidate floor `convention-linear` already calls irreducible for the blocked-by test, so select `stateHistory` **on that same call** rather than paying a second read, and the population is the committed set, never the board. Where a ticket genuinely has no usable state history, derive the age as a **floor** from its due date, its creation date and dated thread evidence, **report it as a floor**, and keep it out of the median and out of the "unmoved a full cycle or more" bucket — that bucket is the one `APP-1171` says is the first that means anything, and it is exactly the one a due-date proxy gets wrong, since the parked Mr Pritchard set carries no due dates at all. (`APP-2405` held that this measure could not be computed, on the premise that the connector exposes no state-change history; that premise is false — `list_issues`' enum carries none, but `get_issue`'s does, read from the schema and exercised live this run — so the note's own option 3 is answered yes and the gap closes with a read. `APP-2400`, filed the same day, already recorded the same mechanism. The rule this serves is `APP-1171`.) Report the per-lane distribution beside the count: the oldest item, the median, and how many have sat a full cycle or more without moving. Depth without age cannot separate a busy cycle from a stuck one, and nothing in this ceremony measured whether the queue was moving — five consecutive zero-output `routine-delivery-loop` runs, 2026-09-03 to 2026-09-08, read as five quiet days rather than as one fully-gated queue (APP-1149). **The unit is the cycle, and it is derived rather than picked:** the boundary is the only point at which this retro observes the board, so one cycle is the smallest age it can honestly see, and on a weekly cycle "unmoved a full cycle or more" is therefore the first bucket that means anything. **This is the measure and nothing else. No threshold is stated here and nothing is gated on it** — the aged-WIP gate on the commit proposal (`APP-1171`, rule 2) needs a distribution to derive a threshold from, and this report is what produces that distribution; a threshold asserted before it exists would be a guess with teeth over the Owner's commit. Deliberately a **different unit** from `skill-plan`'s weekly-snapshot Blocked check, which flags a Blocked ticket untouched for more than two days: that is a daily-cadence signal on a different artefact, so reconcile against it and never restate it here. And once this line exists, no lane's depth is reported in this ceremony without its age beside it.
- **Milestone movement** — which milestones advanced, which slipped, which are now at risk. Movement and "at risk" are only computable where a milestone carries a **target date**; where a milestone in scope is undated, name that as a gap — you cannot assess its drift or roadmap position, and "what needs doing by when" is not trackable for it — rather than reading it as on-track (`APP-625`). Requiring dated milestones at project setup is the systemic fix and sits upstream (project setup / `playbook-client-onboard` / `convention-ticket`), not in this ceremony; here you only name the gap where it bites.
- **The `[goal-review]` output where one exists** — read the most recent `skill-goal-review` summary for the initiatives this cycle served, so the retro reads the cycle against the strategy, not activity alone. Where no goal-review output exists yet, note its absence and retro against milestone and initiative state instead (see *Composition gate*).

- **The cycle goal — was it met? (APP-815)** Read the goal set for the closing cycle — the per-cycle goal document Atlas wrote (filed per `convention-linear`) — and retro against whether that one stated objective was achieved, not only the completion ratio. A cycle can hit its completion ratio and miss its goal, or miss the ratio and still land the goal; the goal is the truer read of whether the week did what it was *for*. Where no goal was set for the closing cycle (the shape predates Atlas owning it), note its absence and retro against milestones and completion alone.

 **And retro against the closing cycle's declared tiers, not the goal alone (Owner ruling, Aled, 2026-09-28, APP-1459).** Where the cycle-goal document declared tiers, read them back: the goal tier is the pass/fail above, the second objective is reported on its own line, and trucking-tier work is reported as throughput rather than as commitment — a trucking item that did not land is not a miss and is not written up as one. Where the closing cycle predates the tiers, say so and retro on the goal alone.

Be honest about what did not land. A clear "this did not move, and here is why" is more useful than a generous reading, and it is the input the rollover and the next commit both depend on.

### The planning-week record — written at the commit, closed at the next boundary (APP-2400, APP-2423)

Each team's cycle carries one `planning-week` record, schema `planning-week.v1` (`data/planning/schema/planning-week.v1.json` in `assoc-one/claude-ops`). It lives in the cycle's own goal document as **one fenced code block whose info string is `planning-week` and whose body is the record as JSON**. The vitals rollup (APP-2426) lifts that block into `data/planning/<team>/YYYY-Www.json` and validates it against the schema. This ceremony writes the block twice, and nothing else writes it:

1. **Open — at the commit, in the Owner's session.** The membership write (Step 4, step 1) appends the block to the opening cycle's goal document with `phase: "open"`. It carries `schema`, `team`, `week`, `window` (the cycle's `startsAt` and `endsAt`), `commit_ts`, `goal` and `stretch` verbatim (`stretch` null where none was set), `pass_condition.beats` numbered from 1 with `met: null`, `committed`, `owner_lane`, `sources` and `notes`. `commit_ts` is **the time of the Owner's instruction to commit**. No boundary recorded it before, and the unplanned derivation depends on it. `committed` is **frozen** here as the approved IDs, because carry-over moves members forward and no later read of the cycle can reconstruct what was committed.
2. **Closed — at the first run after the cycle's `endsAt`.** On the Friday cadence that is the following week's run, which resolves the cycle as `previous` and so reads closed data. Replace the block in that cycle's goal document with the same record at `phase: "closed"`, adding the close fields from the reads Step 1 already makes: each beat's `met`, `beats_met`, `beats_total`, `score`, `stretch_met`, `committed_landed`, `carry_over`, `time`, `new_work`, `unplanned_goal_serving`, `unplanned_share` and `owner_dwell`. Never edit the open fields. A cycle whose goal document carries no `Committed by Aled — <date>` line is closed as `no-commit`, with `commit_ts` and `goal` null, `committed` empty and the reason in `notes`; where the document itself is missing, name the team and week in the summary, because there is nowhere to write the record (APP-1273). **And a third case: the document and its commit line are both present and no block was ever opened.** `replace` is undefined on nothing, so state what a run does rather than leaving each run to resolve it by judgement. The run **reports and skips** — it names the team and week and says that no `planning-week` block exists to close, that the open write is the Owner's at the commit, and that the next commit is the first chance to start the series; it writes no record. It does not synthesise a `phase: "closed"` block from its own reads, because every such record would carry open fields the Guardrail freezes at the commit and this ceremony never edits, and a backfilled series is indistinguishable in the file from a kept one. Recovering the already-missed weeks is therefore a separate Owner-approved backfill, flagged as the `commit_ts_upper_bound` records are, and not something a boundary run does on its own initiative. The report is per team and is made every boundary the block is absent, not once: a silent skip and a kept series read the same in the output, which is the condition APP-1273 is about. (Worked case: the 2026-10-23 W43 → W44 boundary run was the first scheduled run after 2026-W42's `endsAt` and so owed a close on all four teams. `apps.cycle-goal.2026-W42` was read in full and carries no fenced `planning-week` block, and neither does any `*.cycle-goal.2026-W43` — all four read in full the same run — while all four W43 documents carry `Committed by Aled — 2026-10-19`. So W41, W42 and W43 were each committed with the open write skipped, with no check firing on either end, and the run reported the gap on all four W44 proposals rather than inventing a record. **Unverified, and this premise only:** everything repo-side — `data/planning/**`, `planning-week.v1.json`, and whether the W41 and W42 records there were backfilled directly or lifted from a document block — is the filing run's reading of the skill's own citations and was not checked, that run holding the Linear connector alone and no repo ref being readable from this surface either. If backfill is the real path, the rollup's documented input has never carried data while its output reads healthy, and reconciling the two is its own item against APP-2426 and APP-2437 — APP-2649.) A deliberate commit of nothing is `zero-commit`, which keeps its `commit_ts`. On the Friday run the retro lines above describe the cycle still in flight, as of Fri 16:00, while the record closed is the previous cycle's, so the output names both weeks. An on-demand run after the boundary scores and closes the same cycle.

**This is the one body write the ceremony makes after a document's create, and it is bounded.** It replaces the fenced `planning-week` block and touches nothing else: never the `Committed by Aled — <date>` line, the goal prose or the committed list the Owner approved. The no-body-edit rule (Step 4; APP-820, APP-987) exists so that a body write cannot read as approval. Since APP-1567 approval is the marker line alone, so a write confined to the record block cannot forge it. (Placement ruled by the 2026-10-19 drain inside the Owner's APP-2400 rulings: the record lives in the document because the rollup lifts it from there, and this ceremony runs on the Linear connector and cannot write to the repo.) **After every write of the block, read the document back and parse it.** Confirm the block is valid JSON, that its `schema` is `planning-week.v1`, and that every ticket ID survived the save as plain text. Report a block that does not parse by team and week in the run summary. The rollup reports it too, and never skips it silently (APP-2426).

## Step 2 — Roll over

Take every **incomplete committed** ticket from Step 1 and classify each, with a one-line reason:

- **Carry** — still important and still live; moves into the next cycle's candidate set.
- **Drop** — no longer worth doing; propose cancel (a major move — surfaced, never applied here).
- **Return to Backlog** — still valid but not for the next cycle; leaves the cycle and loses its commitment, staying in the backlog.

The rollover is a **draft for Aled**, not an applied change. It proposes the disposition of each incomplete ticket; it does not write it. **Two things are true at the moment this runs (Owner decision, Aled 2026-09-03, APP-1007).** First, cycle automation is off on Apps, A1 and MBN (*Active issues & due date* off, *Started issues* off, *Completed issues* on), so nothing enters a cycle by automation — entry is the commit in Step 3, and this step is real gating for it. **That configuration is named for three teams and this ceremony runs on four — so read the toggle per team, and qualify the gating claim to the teams where it holds (APP-2271).** The automation state is a property of each team's settings, not a list that can be kept true in prose, and on Mr Pritchard it reads differently: on 2026-10-12 seven creates on that team, MRP-72 to MRP-78, each set `state: Todo` and a `dueDate` with **no** `cycle` parameter and each returned `cycleId 8d5c7146-4be8-41c4-96f1-04c0431aebeb` — the *Active issues & due date* behaviour the other three have off. So on that team entry is **not** the commit: a ticket reaching Todo with a due date joins the live cycle without passing the commit, the membership write or the Owner, and the same field is what makes MRP-70's native weekly recurrence fire, so the two cannot be separated without changing one of them. State the claim as holding on the teams whose automation is off, name the team where it does not, and read a zero-explicit-write membership diff on such a team as unattributable between the commit and the automation rather than as evidence the commit landed. **Unverified premise:** Mr Pritchard's *Started issues* and *Completed issues* toggles were not exercised and are not asserted — a workspace-config setting is not readable from this surface (`convention-linear`, *Never in a delivery cycle*), so this records observed behaviour as a dated observation and nothing about the toggles themselves. Whether that automation should be on at all is an Owner config call, surfaced as APP-2297 and never assumed (`convention-comms-owner`, *Control-plane actions*). Second, Linear's built-in carry-over of incomplete issues still runs at the boundary, so every ticket still open on Sunday night lands in the opening cycle, whatever the proposal says. **On the Friday run that has not happened yet.** State *Drop* and *Return to Backlog* as **"do not carry into cycle N+1"**. The approved removal can only be applied once the carry-over has placed the ticket in cycle N+1, which is after the boundary. Until then, the approving session reports it as outstanding and never as applied, and it is applied after the boundary on the Owner's instruction, under the same clause as the rest of the membership write (Step 4; APP-1577, APP-1580, 2026-09-21). On an on-demand run after the boundary, the carry-over has already happened, and Step 2 is a **reconciliation pass over it**. *Carry* means it stays. *Drop* and *Return to Backlog* are proposed **removals from the opening cycle**, stated "remove from cycle N+1". Either way, word it so the write he is being asked to make is the one that is actually outstanding.

**Never strip a Done ticket from a closing cycle.** Linear's cycle-completion metric *is* the count of completed issues in scope (`completedIssueCountHistory` against `issueCountHistory`), so removing Done tickets drives the completion rate toward zero and destroys the burn-up — the write done for "cycle hygiene" would be the thing that wrecks the history the retro depends on (`APP-585`). Only **Canceled** tickets are ever stripped from a cycle. (This protects the burn-up; it is not the throughput read — Step 1 reads throughput from `completedAt`-in-window, `APP-891`.)

## Step 3 — Propose the next commit and the cycle goal

**Propose the cycle goal (APP-815).** Alongside the candidate set, propose **one goal for the opening cycle** — a single stated objective for Aled's whole delivery capacity (e.g. "assoc.one foundation shipped and reviewable"), not a ticket list. **One goal, not one per team** — Aled is a single delivery capacity across Apps / A1 / MBN / Mr Pritchard, and several concurrent goals is no goal; the goal names the venture it serves. Name any **stretch goals** separately: a stretch goal is stated but **never occupies a WIP slot** until the required set is done. Express the capacity split as the **tiered Owner-lane ceiling** below, never as a reserved-slot floor and never as a percentage: a reserved floor states what goal work may not lose, which read literally made every non-goal ticket formally ineligible to be pulled — the starvation APP-1459 recorded, with one team's own document instructing it to stay out of the way in place of a goal — whereas the ceiling states how much of the Owner's attention each tier may claim and leaves agent throughput unconstrained (Owner ruling, Aled, 2026-09-28, APP-1459). This supersedes the reserved-WIP-slot form for this ceremony; `standard-prioritisation` still carries that form. The goal is **propose-only**, approved at the same gate as membership; once approved it is written **by the Owner**, or by the agent in his session on his explicit instruction (APP-1580), into the per-cycle goal document — the document Step 4 creates at proposal time and files per `convention-linear` — which the standup, Aide, and the next boundary's retro all read. Approval writes the goal in; it does not conjure the document. **The goal carries its pass condition as numbered, independently checkable beats** (`skill-operating-loop` step 2): one condition per beat, 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 proposal is posted (APP-2400).

**Tier the board per cycle — goal, second objective, trucking (Owner ruling, Aled, 2026-09-28, APP-1459).** One goal across the whole delivery capacity stands and is reinforced; what it was missing is the rest of the board's relationship to it. Alongside the goal, declare **three tiers in the cycle-goal document**, as a per-cycle attribute and never a property of the project: **goal** — one, taking almost all of the Owner's attention; **second objective** — one named slice; **trucking** — every other live project, which agents work at full throughput, whose decisions the **operators** own, and from which nothing reaches the Owner except a stated exception list: a client waiting, money, something irreversible or public, or a hard external date. **The tier sits above the project priority field**: where a project's priority and its tier disagree, the tier governs for that cycle. **Slippage is absorbed before it reaches the Owner** — a goal-tier item that slips holds its place and displaces the lowest-tier item still in the week; the displaced item routes to its owning operator to absorb, hold or re-sequence, and reaches the Owner only where it fails that operator's own grant test (`skill-operating-loop` step 5). A trucking-tier item that slips drops out of the week rather than pushing goal work along. The complaint this answers was that one goal starves the other teams; the ruling is that they are **subordinated and absorbed by their operators**, not starved — they keep delivering at full agent throughput, and what changes is that their decisions stop arriving at the Owner's desk with the goal's weight. **Per-team goals are explicitly not the remedy**: four goals is no goal, and each team would then generate its own independent claim on him. (Measured at the 2026-09-25 boundary: the W40 proposal put **28 items in the Owner's lane** across four teams, of which **seven** served the stated cycle goal. APP-815 stands and is reinforced; APP-1459's own title remedy — goal scoped per team, WIP reserved per team — is superseded by this ruling and is not implemented.)


**A standing target declared on a team's outcome-initiative is read, not derived — and it is not a second cycle goal (Owner, 2026-10-05).** The Owner's words were: *"Mr P should have one thing to post and a stretch goal of two, with 3 comments on other people's posts and one reshare — this should be standing weekly goal."* The ruling above — *per-team goals are explicitly not the remedy* — governs the **derived** cycle goal, the one claim on the Owner's attention, and it stands unchanged. A standing target is a different object: its home is the venture's outcome-initiative, declared once as an objective and its KPIs (`skill-strategy-cascade` / `skill-strategy-charter`, Atlas's layer; MRP-19 is the open ticket carrying Mr Pritchard's), and this ceremony **reads** it rather than re-deriving it. So at each boundary, for each team at a boundary: read its outcome-initiative's objectives and KPIs for a standing weekly target, and where one exists, state it in the cycle-goal document as a **standing** line of its own — the target, and the initiative it is read from — placed above the tiers and separate from the derived goal. **A standing target does not take the goal tier and does not compete for it.** It sits with its team's trucking tier as a floor that tier carries, which is the one case in which trucking work carries a commitment: reported against its target, not merely counted as throughput. A trucking team that nonetheless owes a weekly number is exactly what the Owner has asked for, and the tier model absorbs it without amendment once the target's home is the initiative rather than the cycle. **And a standing target's tickets are planned by construction.** They belong on the committed list whether or not the Owner re-lists them each week, and the retro reads them as planned — they are the most planned work on the board, so `cycle:unplanned` on one of them is a derivation artefact and not a signal (Step 1; APP-1095; `skill-coordinate` derives the label by diffing membership against the committed list and cannot know the target). Where such a ticket is found carrying `cycle:unplanned`, name the count and exclude it from the unplanned share rather than letting it inflate the figure. **Written only into a cycle-goal document, a standing target dies at the boundary** — the APP-1546 shape, in which the thing meant to recur stops and no check fails. The initiative's KPI line is the source of truth; a native Linear recurring issue is its mechanical expression, not the target itself, because editing a template does not change recurrences already created from it (MRP-70 is the Owner-lane, UI-only setup ticket — the connector exposes no recurrence parameter on an issue write). (APP-2038. APP-815 and APP-1459 stand.)

**And test each agent-lane act for surface reachability before it enters the committed list (APP-2282).** A committed act can be well-formed, correctly routed, correctly labelled and correctly prioritised, and still ask for something **no lane on the current surface can reach** — a human feed, a credential-gated console, a physical object, a rendered screen. Nothing upstream tests it: `skill-build-ticket` step 3b tests the ticket's shape at the claim and `skill-triage` tests it at routing, and neither asks whether the named executor can perform what is asked. The failure is self-concealing in the worst direction — an impossible criterion produces a *blocked* report from a competent agent, which reads as a slow week — and it **survives re-commissioning**, because a retro reads the outcome (not prepared) and re-issues the instruction. This ceremony already reads each committed ticket to write the cycle-goal document, so it costs one question per agent-lane act: **can the named executor actually reach what this asks for?** Where it cannot, split or re-scope before commitment, to the shape `convention-secrets` and `convention-ticket` already set for credential-gated work — a `human` leaf for the part only the Owner can perform, a fleet leaf for what the lane can produce — rather than committing the whole and discovering it at the deadline. Where an agent has already declined an act for want of surface access, **that decline converts the criterion**; it is not merely reported against. A venture's own list of unreachable surfaces belongs in its `operator-<venture>` profile, where it can be checked in seconds, and is that operator's to maintain. (Worked case: Mr Pritchard's standing weekly goal commits one post, three comments on other people's posts and one reshare. Reach's W41 run on MRP-71 produced three fully drafted comments, a reshare framing line and a reshare test, and declined to guess a candidate post — *"this leg has no access to his feed and has not guessed at a candidate"* — which was correct. All four engagement acts scored zero and the boundary retro recorded them as never prepared. MRP-78, filed at the W42 commit on 2026-10-12 and due the 15th, carried the criterion unchanged; the `task-mrp-operator-loop` run of 2026-10-12 waived it on evidence (`convention-ticket`, *Waiving a box*) and re-scoped it to a paste plus named authors and a search phrase. That the fleet holds no LinkedIn connector, and the ticket identifiers, dates and quotations, are the filing leg's report and are **unverified** here, no connector roster, document or ticket being readable from the refine surface; that flag covers those only, not the canon absence, which was read live — APP-2282.)

**And a premise a beat states about a named ticket carries that ticket's thread read, to the end, before it enters the proposal (APP-2675).** The clause above tests whether a committed act can be *performed*; this one tests whether the reason given for it is still *true*. A beat that makes one ticket a precondition for another — *X must land first, because Y cannot proceed until it does* — rests on a claim about the named ticket's state, and that claim is exactly the kind that lives in a thread and moves no field: an Owner correction, a hold, a re-scope and a ruling all leave the labels, the state and the estimate reading as they did before. So read the named ticket's own `list_comments` to the end, write the premise **from the thread rather than from the fields**, and carry the read in the proposal line (`A1-543, thread read to end 07:45Z, clause-15 dependency withdrawn 2026-10-14`). **The rule fires on every ticket a beat's premise names as a cause, a blocker or a precondition** — not on every candidate in the set, which would be unbounded — and it fires at the proposal's own write, not on a later review of it. **And a proposal already posted and not yet committed goes stale in place, so a boundary run that finds last week's proposal uncommitted supersedes it explicitly rather than leaving it standing.** The rule above binds the **write**. Nothing binds the document afterwards — and an uncommitted proposal is exactly where this failure concentrates, because the longer it sits the more likely a thread has overtaken a premise it states, so the rule's coverage runs inversely to the risk. The cost is not tidiness: the document is the Owner's commit surface, and approving it as written commits the false premise with it, including a beat scored as still-to-achieve that was achieved before the document was posted and a beat committing the Owner to an act he had paused on a different condition. So where this ceremony's boundary read finds the previous cycle's goal document still `PROPOSED — NOT COMMITTED`, post **one `[cycle-planning] SUPERSEDED` comment on that document** naming the new cycle's proposal, and **naming every premise the new run corrected against a thread** — one line per corrected beat, with the ticket, the thread's own date and what the thread said. **A comment and not a body edit**, deliberately: the no-body-edit rule (APP-820, APP-987) reads any membership-shaped write on a proposal as approval, and a comment cannot, so this takes the one instrument that carries the correction without forging the gate. **It does not close or retire the document** — who may retire an Owner decision is the Owner's, not this ceremony's — and it does not add a thread-reading obligation to any daily pass: the re-reads are the ones step 3's rule above has already performed this run, written down a second time against the old document instead of discarded. This is the same act the commit-deadline ticket already takes at the other end of the same event (*where the proposal is superseded rather than committed, cancel it the same way and say which*), reaching the document the ticket was filed about. (Worked case: `a1.cycle-goal.2026-W44` was still live, still `PROPOSED — NOT COMMITTED` and still carrying both falsified beats six days after APP-2675 was filed about them, while the W45 boundary run complied with the rule above, read A1-543's thread to the end, withdrew the premise and re-stated the goal — so the fix held where it was specified and the stale document stayed the live commit surface for a week regardless. That run's reads, the document's status and A1-543's three thread entries are the filing run's **report** and are unverified here; that the rule above binds the write alone is **observed**, read live this pass — APP-2795.) Where the thread contradicts the premise, the beat is re-stated from the thread or dropped; it is never posted with the stale reason under a caveat, because the document is the Owner's commit surface and approving it as written commits the false premise with it. **And a question the thread shows already ruled is not re-opened as a choice.** Re-framing a settled measure as still-open reads, to the one reader whose approval is being asked, as a fresh decision he owes an answer to; so a proposal that restates a ruled question cites the ruling and its date instead of re-asking it, and a measure ruled once is not re-proposed a second, third or fourth time because each new document is drafted without reading the thread that settled it. This is `skill-operating-loop`'s read-to-the-end rule and the closed-ticket limb above reaching the **forward** side of this ceremony, where the cost is the Owner's commit rather than a retro line. (Worked case, **reported** from the filing run's reads and unverified here: `a1.cycle-goal.2026-W44`'s beats 1–2 made A1-543 land-first on "Clause 15: the fractional agreement cannot be sent until this is true", while that ticket's thread carried the Owner's 2026-10-14 correction that the agreement had gone and that the purchase was not blocking clause 15, and a 2026-10-21 ruling holding the purchase elsewhere; that proposal had read one other cited ticket's thread to the end and not the thread of the beat it rested on. The same run's `mbn.cycle-goal.2026-W44` re-framed MBN-321 as "raw sessions or addressable (UK) sessions, and at what thresholds" for a fourth time, a measure ruled on 2026-09-29 and acknowledged thresholds-only on 2026-10-02, and its 23 Oct revision comment repeated the framing. APP-2420 covered W43's document and is Done; its fix did not reach this ceremony's write of the next document. Fifth limb of the family at APP-1935, APP-1976, APP-2167 and APP-2420, and the first firing inside this ceremony rather than in a vertical stand-up — APP-2675.)

Produce a prioritised candidate set for the opening cycle:

- **Never a `PUL-5E` note — excluded by construction, at the write.** The candidate set, and the membership write Aled later approves, exclude every ticket carrying the bare `PUL-5E` executor value; filter on that bare value, the same one `skill-plan` uses. A `PUL-5E` note is propose-only canon intake and never joins a cycle (`convention-linear`, *Never in a delivery cycle*, APP-870) — `skill-plan` already subtracts them on the read side, but nothing filtered them at the commit, so Apps cycle 6 carried ~30 of them and read scope 73 against ~43 real delivery scope, corrupting every consumer that did not know to subtract (APP-1038). Enforce once at the write rather than compensate at every read. **The write-side exclusion holds and is not enough, because these notes do not enter by the write.** With *Completed issues* automation on (`convention-linear`, *Never in a delivery cycle*; APP-1007), a ticket joins the cycle by being completed, so a Pulse drain that closes a batch of notes adds that batch to the live cycle with no commit, no membership write and nothing for a commit-time filter to intercept. The exclusion above is specified on a path these tickets never take. So **Step 1's boundary read subtracts them too**: filter the closing cycle's membership on the bare `PUL-5E` executor value before reporting scope, the completed count, the planned-versus-unplanned share or the `completedIssueCountHistory` cross-check, and report the subtracted figure as the cycle's, naming the excluded count alongside it. This is not a reversal of APP-1038 — that ruling rejected compensating at every read *instead of* enforcing at the write, and the write-side enforcement stays. It is the reading-end half `convention-linear` already sanctions for the completions automation specifically, and the same subtraction `skill-plan` already applies. **The correction is not retrospective.** APP-585 forbids stripping a Done ticket from a cycle, so a burn-up already tracking drains cannot be repaired; only the reported figure can be. (Worked case: Apps cycle 9 closed at 222 members and 204 completed, of which 117 carried the bare `PUL-5E` value — 107 of them in six bulk-close batches of 9 to 29 inside two-minute spans — against roughly 105 real delivery scope and 87 real completions; three notes were in cycle 10 and Done within a day of it opening. APP-1425.)
- **Drawn top-down by priority — the commit is not priority-blind.** Order the candidate set by priority first: the Priority Board (project rank) and the latest `skill-plan` focus recommendation are **required, gating inputs**, taken from the top down until the throughput ceiling is reached. Read `skill-plan`'s most recent focus output and the project priority ranking before drafting the set; where the focus output is stale or absent, say so and fall back to project rank, rather than committing whatever the board happens to hold. A hand-committed, priority-blind cycle is the observed failure — the first live Aide day booked work not linked to the most urgent board items, because nothing fed priority into the commit (`APP-625`). Priority orders the set; the initiative-tie below filters it; throughput sizes it.

**And the gating input's freshness is read, not assumed — the ceremony states whether it consumed the focus output or fell back.** The rule above gives the disposition for a stale input and no test for staleness, so *stale* has been a judgement made fresh each run. Make it deterministic. Read `skill-plan`'s focus output and take its age from the document's **own stated date line**, not from `updatedAt` alone: the snapshot is replaced in place each run, so there is no history, and a four-day-old body is indistinguishable from a fresh one except by that line. Where the stated date is more than **24 hours** before this run's actual fire time, the output is stale. Then state the disposition in one line at the head of the proposal — `Focus output <YYYY-MM-DD>, <n>h old: consumed`, or `Focus output <YYYY-MM-DD>, <n>h old: stale, fell back to project rank` — naming the date, the age and which of the two happened. The fallback to project rank is unchanged; what changes is that it is declared rather than silent, so a reader can tell a commit drawn from a fresh recommendation from one drawn from the board alone, and a fallback that has become the permanent state is visible as such instead of reading as the exception the rule assumes. A gating input whose headline claim is four days out of date and was falsified within the hour of being written is worse than no input, because it reads as current. This instantiates `core-operating-model`'s catch-up contract — every run states its actual fire time and degrades explicitly rather than presenting a discontinuous record as continuous (APP-993) — on an input rather than on a run; it is not a new rule. (Worked case: the first Friday boundary run under the 16:00 cadence, 2026-09-25, read `osclaude.focus-snapshot` dated 2026-09-21 05:35Z — four days old, opening "Uncommitted on all four teams: no `cycle-goal.2026-W39` document exists anywhere", which was true when written and superseded about an hour later, when the W39 proposals were filed at ~06:37Z and committed at 08:42Z. The run fell back to project rank by judgement and nothing in its output said so. Under the two current cadences — `skill-plan` on Monday, this ceremony on Friday 16:00 — the stale branch is the standing case, which is the point: the declaration is what makes the cadence question visible instead of leaving the gating-input requirement satisfied only nominally — APP-1787.)

**The not-started-but-full predicate is `skill-plan`'s, and this ceremony consumes it rather than computing it (`APP-2415`).** Where the commit needs to know whether a candidate project is misreported — a project whose `statusType` is `backlog` or `planned` while it holds any started or unstarted ticket — take the answer from the focus output read above and cite it as `skill-plan`'s. **Never recompute it here, and never publish a second list.** `convention-project-status` defines the predicate and names a single surfacer — `skill-plan`'s weekly cross-project pass, which the same file calls the hygiene surface and *not a second health writer* (`APP-893`). This ceremony carries none of that definition: no `statusType` read, no project-status read, nothing. So a boundary run that publishes its own list is computing a check no canon here instructs it to compute, against an exclusivity clause stated elsewhere. The cost is not duplication, it is unanswerability — the ask behind the predicate is a major-level Owner proposal per project, so two lists published three days apart make it unanswerable rather than twice-answered. (Worked case: this ceremony's 2026-10-16 run and `skill-plan`'s 2026-10-19 pass each named four projects for the same predicate; only two were shared and the disagreements ran both ways.) Where the focus output is stale or absent, the predicate is absent with it: say so in the same line that declares the fallback, and propose no list of your own. The rule is stated **here**, in the line this ceremony actually reads, rather than left where it already sits in `convention-project-status` — restating a prohibition in the file that already carries it does not reach a run that reads a different file (`APP-2334`).
- **Tied to initiative objectives.** Each candidate maps to an active outcome-initiative or a near-term milestone. Work that maps to neither is drift — name it as such rather than committing to it. Where no outcome-initiatives exist, fall back to milestone-target and priority, and flag the gap (as `skill-plan` does).
- **Sized against observed throughput, not a full board — and report both a batched and an unbatched figure (APP-891).** The commit is sized to what recent cycles actually delivered inside the window, not to optimism and not to a backfilled burn-up. Take the `completedAt`-in-window throughput from Step 1 as the ceiling, and report **two figures side by side**: a **batched** figure (all completions in the window) and an **unbatched** figure (the same window with an obvious bulk-close drain set aside — for example a run of dozens of completions landing within minutes of each other, which is real work but not repeatable weekly capacity). **Size the commit on the lower of the two.** Do **not** pick a bulk-close exclusion threshold: a threshold is a magic number that will be wrong at the next boundary, whereas reporting both figures makes the divergence visible at commit time and leaves the judgement with Aled — a drain closing 64 notes in 11 minutes should not size the next week. If a team has been delivering ~74% of a 74-ticket scope once the drain is set aside, a proposal of a full fresh board is a cycle that cannot land. **Overcommitment is the known failure** — a cycle running well past capacity is one that never completes and that Aide then cannot book (`APP-581`). Size down to what the lower figure supports and say what was left out. The `APP-581` coupling runs both ways off the same undefined number: an inflated ratio says "the fleet cleared 135, so 135 is affordable" and commits the overcommitment `APP-581` records; a cycle backfilled with OPEN work reads low and **undersizes** by the same mechanism. Defining throughput as `completedAt`-in-window and sizing on the lower figure closes both.
**And the throughput ceiling's denominator is a closed cycle, never the Friday run's own open partial window (`APP-2794`).** The bullet above fixes what Step 3 *counts* — `completedAt`-in-window completions, reported batched and unbatched and sized on the lower — and leaves the *window the denominator is measured over* unstated, which is where the ratio comes apart: the numerator is a **full** cycle's deliveries while the denominator, on a boundary run that fires inside the week, is the cycle still open and only part-way through its length, so the two sides are measured in different units and the ratio the commit is sized on swings with the hour the ceremony fires rather than with any change in load. The rule is categorical: **the denominator is measured over a trailing full cycle — the one that has just closed — or over the previous closed cycle, and never over the open partial window the run is standing in**, and **the measure carries its window length wherever it is stated**, so no reader meets a throughput figure without seeing what it was divided by. Where no closed cycle is available, fall back to a trailing **7 days** and **say which of the two was used**; a figure stated without its window is not a throughput figure and nothing is sized against it. A trailing **3-cycle average** was weighed as the third option and is **rejected as over-damped** — it smooths away exactly the boundary-to-boundary movement the commit is meant to respond to — and the rejection is recorded here so a later pass does not re-propose it as the obvious fix. This settles a *how/where* question inside a *what* the Owner has already ruled: the ceiling itself, and that the scarce resource it allocates is Owner attention, are the Owner ruling of 2026-09-28 recorded at `APP-1459` and are untouched here, as is what Step 3 counts; only the window the measure is taken over moves, which is refine's to rule rather than the Owner's. (Worked case, **reported** by the filing run from its own reads and not re-derived here: one lane read 31 against a denominator of about **10** and then 35 against a denominator of **3** across a single boundary, on a window measured at **4.6 of 7 days** — a swing of roughly **7.6×** with no load change. Every figure in this case is **reported** rather than **observed**, and the rule above holds independently of all of them: it is a units argument, not an argument from the size of one swing.)

- **Carries the rollover.** The carried tickets from Step 2 are part of the commit's weight, not free additions on top of a fresh board — count them against the throughput ceiling first.
- **Names every dated commitment inside the proposed window, and says what happens to each.** Before the set is posted, list every goal, objective, milestone and gate target date falling between the proposed cycle's `startsAt` and `endsAt`, and state per date whether it is committed in this set, deliberately excluded with a reason, or escalated. A date inside the window carrying none of those three dispositions is an omission, and the proposal names it as such rather than leaving it to be found on day three. The charter and the milestone list are already open for the initiative-tie read above, so the cost is one line per date; what it buys is an exclusion list that is exhaustive rather than illustrative, and a reader who can tell a date nobody chose to drop from one that was weighed and dropped. This is the proposal-time half of the check `skill-operating-loop` makes at loop time — one read at each end, because a commitment missed at the write is invisible to every later read that trusts the committed list as the definition of *planned*. (Worked case: A1's cycle 12, 2026-09-27 to 2026-10-04, was proposed and committed with a five-item list, a held-back slot and an explicit exclusion list naming four tickets, and with no mention of O6 — `assoc.one` live by 1 October — whose gate fell on day five of eight. The gate milestone and both milestones feeding it read 0%, and the four tickets beneath it had sat Urgent in Backlog for a week. Nothing in the proposal was wrong; the window's contents had simply never been read — `APP-1861`.)

**The enumeration includes the committed set's own ticket due dates, and the ceremony ends with one set-difference against the committed list.** Two additions, and the first is a **widening rather than a correction**: the enumeration above covers **goal, objective, milestone and gate** target dates, so a committed ticket carrying a due date inside the window was never in its scope. An omitted one is therefore **not a breach of this rule** — it is the rule's enumeration being narrower than the claim the ceremony's own table writes, with nothing reconciling either against the committed list. The enumeration now also carries **every due date on a ticket in this set that falls inside the window**, which closes the gap between what is asked for and what "exhaustive" asserts. Then, once the table and the committed list are both written, **one set-difference, both directions, with the asymmetry kept.** Every committed item carrying a date inside the window **must** appear in the table — a **hard failure** where it does not, because the table is the artefact a later reader trusts *instead of* re-deriving the dates, so an omission there is not a gap someone notices but a gap someone relies on. Every table row inside the window is either committed or covered by the explicit exclusion list — a **prompt** to name which exclusion covers it, not a failure, because the table may legitimately hold a dated item deliberately excluded with its reason. It costs **no new read**: both sets are already open in the same document, and the output is a line rather than a query. The mechanism it closes is a **late arrival** — the table is built from a board sweep and the committed list from the commit conversation, each correct about its own source, so an item entering the commit after the sweep lands in the list without landing in the table. **The fix is the diff and not the sweep's timing**, because the same late-arrival shape is already in the record having done no harm. (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**: `a1.cycle-goal.2026-W43`, document `842c06fc`, committed 2026-10-19 08:56Z, carried a section headed *"Dated commitments inside 2026-10-18T23:00Z → 2026-10-26T00:00Z — exhaustive"* with two rows, A1-429 and MRP-80, and the closing claim *"Verified across every milestone target date, every project target date and every live ticket due date on all five teams. Nothing else falls inside the window."* A1-715 was **absent from the table while present in the same document's committed list** — *"Todo, High, 1 pt, due 2026-10-19 — today"*, `dueDate: 2026-10-19` — and went overdue on day one with the one surface built to catch that saying nothing fell due. A1-716 is the same late-arrival shape doing no harm: goal document written 14:53Z, ticket created 15:51Z, and it made the list. The loop's own step 1 check is what found the omission and is working as written; nothing here changes it. `APP-2488`, one level down from `APP-2256`, where membership and work diverged rather than a list and its own table.)

**And the enumeration carries each dated row's executor, so an in-window dated row still sitting in the triage lane is named at the commit (`APP-2848`).** The rule above widens the table to **every in-window ticket due date** and diffs it both ways against the committed list, and of each row it asks only *whether it is committed* — never *whether any surface is obliged to read it before its date*. That is the gap, and it is the `APP-2439` shape rather than a missing field: a ticket filed behind a goal enters the board carrying `agent:R3-LAY` by the create-time default (`convention-ticket`, the routing invariant, bound to Linear in `convention-linear`), and `skill-triage` bounds its own pass at *"at most five rows per delivery team per fire, first touches first, remainder named"* — a cap on the **work** and never on the **scope**, so an eligible row stays eligible and nothing promises it is reached. A row correctly projected, correctly labelled, prioritised and dated inside the window, left in that lane, is therefore queued behind a cap that cannot be relied on to reach it before its own date, and the correction depends entirely on a later read happening in time. So the dated-commitments table **states the executor value each in-window dated row carries**, and where a row carries `agent:R3-LAY`, the proposal **names it as needing promotion at the commit**. It costs **no new read**: the label comes back on the same board sweep that builds the table, and the output is a line rather than a query. Two boundaries this draws: it is a **report, not a route** — this ceremony stays propose-only, **chooses no delivery executor**, and writes no label, so the write scope above is untouched and whether a scheduled ceremony may pick an executor at all remains an open Owner question that this rule does not answer; and the **absent disposition is not a fourth disposition** — a named row is still committed, excluded or escalated exactly as the enumeration already requires, with the lane stated beside it. What moves is only *when* the mismatch is visible: the commit the Owner is already making becomes the forcing function, instead of the next weekly read. (Worked case, **reported** by the filing note from its own reads at 2026-11-03 12:1xZ and **not re-derived here**: four fleet legs filed behind `a1.cycle-goal.2026-W45` at 09:33Z, dated 11-04, 11-05 and 11-06, created in `Backlog` under `agent:R3-LAY` behind a lane the same run read at **73** `R3-LAY` rows of **136** backlog-type on one team — roughly fourteen fires' worth at the cap, with the first date three days out. The catch was timing: the amendment landed about two and a half hours before that team's weekly loop fired, and on any other weekday the next surface obliged to read those rows would have been the following week's loop, after all three dates had passed. **Observed** on the live board at this refine: three siblings from the same 09:33Z sitting — `A1-876`, `A1-877`, `A1-878` — still sit in `Backlog` carrying `agent:R3-LAY`, while `A1-874` was promoted to Todo under `DR-4FT` by that loop. The rule holds independently of the population figures: it is an argument about a cap that bounds work and not scope, not an argument from the size of one lane.)

**Platform behaviour vs. what canon reads (APP-891).** Whether Linear populates a cycle with already-Done work at its start — the day-one burn-up opening at 62% — is **platform behaviour canon cannot change**. Canon can only decline to read that opening as throughput, which is exactly what the `completedAt`-in-window definition above does. Do not attempt to make Linear start the cycle clean; read the number correctly instead.

**The coupling to Aled's capacity — name it, do not silently absorb it.** The commit proposal is what **Aide** reads to turn Aled's slice of the cycle into booked time (`APP-430`). A commit that ignores the Owner's actual available hours produces a cycle Aide cannot book — the committed cycle has run ~1.8× Aide's hold-window capacity (`APP-581`). Where the Aled-lane share of the proposed commit is plainly large, **flag the coupling in the proposal** so he sees it at commit time — stated in terms this Linear-only ceremony can actually read: the count of Aled-lane items in the proposed set, the In Review depth awaiting him, and the count of items Blocked on him. The ceremony never states hours: it has no Calendar read, and an instruction that asks for a figure the run cannot compute is either fabricated or silently dropped (the 2026-08-22 cycle-6 run substituted an item count and had to say so — APP-1054). The hours comparison against the hold windows belongs to Aide, which holds the calendar (Owner decision, Aled 2026-09-03). The fix for the capacity itself sits in Aide, not here. **But the coupling is the sizing constraint, not a closing note (Owner ruling, Aled, 2026-09-28, APP-1459).** The scarce resource this ceremony allocates is **Owner attention**, not agent throughput. So size the Owner lane first: take the **Owner-lane item count of the opening cycle's projected membership** as the ceiling — the committed list **plus** the carry-over, which is knowable at proposal time — allocate it across the three tiers declared with the goal, and **commit at roughly 75–80% of that ceiling, leaving the last slot of each day unfilled** — the held-back capacity and the trucking tier are the same pool honestly labelled, and unexpected work and trucking work compete for that residue with the more urgent winning. **The projected membership, not the committed list, because the ceiling is enforced at the commit and Linear's boundary carry-over does not read the commit.** Every still-open ticket moves into the opening cycle whatever the proposal says (Step 2; `convention-linear`, APP-1007 — the built-in incomplete-issue transfer, which is not the *Active issues & due date* toggle and cannot be turned off). So a trucking tier declaring that *nothing reaches the Owner* produces a cycle in which a great deal reaches him, while the ceiling reads satisfied because the commit was small. Measured at the 2026-10-04T23:00Z boundary: three of four teams proposed an Owner lane of **zero** or **one**, A1 committed five, and **19 open Owner-lane tickets** carried over regardless — then read six hours after the open, the actual was **26 Owner-lane of 30 total members** across the four cycles, worse than the projection because A1's proposal was never approved either and its own five became residue like everyone else's. **Count the residue across all four teams against one ceiling, not per team.** The tiers are declared per team; the attention they spend is one Owner's, so a trucking team's carried Owner-lane residue counts against the goal team's ceiling — that is what APP-1459's ruling means by sizing the scarce resource. **Two consequences to report alongside the figure, because they are what the carry-over does to the downstream reads.** First, `skill-coordinate` Pass 7 derives `cycle:unplanned` by diffing membership against the committed list, so carried Owner-lane tickets against a near-empty commit read as ~95% unplanned — inflated by the carry-over, not by unplanned work (APP-1095's figure measuring the wrong thing). Second, carry-over selects on *still open*, and the population that stays open is the population only the Owner can close, so each uncommitted boundary concentrates the cycle further toward Owner-lane work while agent-routable work stays **outside** the cycle entirely: at the 2026-10-05 read, **zero of 30 members carried an agent executor** and two carried no executor label at all. **Stripping the carried tickets is not the remedy** — they are live work, and removing them hides the load rather than sizes it. Report the projected Owner-lane figure, size against it, and name the residue. (APP-1991; the uncommitted-boundary condition it compounds is APP-1994.) Agent, operator and automation work stays a separate and much larger number and is **explicitly unconstrained in volume**: it is constrained only in what it hands back to the Owner, and the throughput sizing above continues to govern it unchanged. The ceremony still states no hours — the Owner-lane figure is an item count, which is what this Linear-only surface can read.

## Step 4 — Post the proposal, do not commit

Post one commit proposal per team for Aled — the output block below — **as a comment on that team's per-cycle goal document** (`<team>.cycle-goal.YYYY-Www`, filed per `convention-linear` *Documents and the decision log*), which this step writes first where it does not yet exist — see *Write the goal document before posting anything* below. That is the proposal's one home for every team, including a team with no mirror initiative: on 2026-08-22 three teams' proposals landed in three differently chosen places and MBN's on an unrelated initiative, so the consumer that tests freshness against "the latest proposal" had nothing deterministic to find (APP-1054; Owner decision, Aled 2026-09-03). **Nothing is written to any cycle.** The proposal states explicitly that it awaits his approval. When Aled approves, the cycle membership is written in the session where he approves, on his instruction, and never by the unattended scheduled run that posted the proposal (see *The membership write* below; APP-1580, 2026-09-21). Where several teams are at a boundary in one run, post one proposal each; the runs are independent per team.

**Write the goal document before posting anything — per team, and report every team left without one.** The proposal's home is the goal document, so the document is this step's **first** write, not a clause of the posting write. For each team at a boundary: resolve the opening cycle's ISO week from its `startsAt` (cycle 9 opening 2026-09-06T23:00Z is `2026-W37`). On the Friday run the opening cycle is `type:"next"`, so a Friday 2026-09-25 run creates `<team>.cycle-goal.2026-W40` (APP-1577), search the documents store for `<team>.cycle-goal.YYYY-Www`, and where none exists **create it, then post the** `[cycle-planning]` **proposal as a comment on it — in that order**. The body it is created with is the **proposal only** — the proposed goal, the proposed committed list, each line marked *proposed — not committed* — because the committed list is the definition of *planned* and only the Owner's write makes it the commit (`convention-linear`, *Labels*; APP-1095). Creating the document is an agent write and is **never** the approval marker: the marker is the `Committed by Aled — <date>` line added on the Owner's approval (APP-1567). The ceremony never writes that line, and it never edits the body after the create (APP-820, APP-987), save the one bounded write of a closed cycle's `planning-week` block (Step 1, *The planning-week record*). Step 3's *once approved it is written to the per-cycle goal document* is that Owner write into the document created here, not a reason to leave the document uncreated. **Where a team ends the run without a goal document — the create failed, no opening cycle resolved, the run stopped early — name that team, its cycle and the cycle's end date in the summary and end on that, never quietly.** A ceremony that skips the write silently is indistinguishable from one that never fired, and every downstream approval test is then specified against an artefact that has never existed: `skill-coordinate` Pass 7 has no committed list to diff, so no `cycle:unplanned` is derived anywhere, and `skill-attention-sweep`'s freshness test reads a cycle that was never committed. (Observed 2026-09-11, 04:20–04:47Z: Apps, A1 and MBN each ran a live cycle 9, 2026-09-06T23:00Z → 2026-09-13T23:00Z, at 159 / 37 / 8 issues, and **no cycle-goal document of any shape existed anywhere in the workspace** — `cycle-goal`, `cycle goal` and `2026-W37` all returned empty, and the newest 60 documents held none, so no earlier cycle has one either. Three teams, three live cycles, no commit on any of them — APP-1273.)

**The approval signal downstream consumers test (APP-820, APP-987).** When Aled approves, the goal document's body is rewritten to the approved goal and committed list (the *proposed — not committed* markings removed), and it carries the **approval marker: an explicit line `Committed by Aled — <YYYY-MM-DD>`** (Owner decision, Aled 2026-09-21, APP-1567). **The marker is that line. The write's timestamp and author are not the marker.** Every connector write authors as *Aled Pritchard*, so neither the author field nor a later `updatedAt` can tell the Owner from the fleet. Worked case: `a1.cycle-goal.2026-W38` was updated at 2026-09-14 11:07, after its 06:42 proposal comment. Its body still read *proposed, not committed*, and no membership write followed, yet it passed the timestamp test as approved (APP-1567; the same shape as APP-1466). **No agent writes the marker line on its own account**: not the ceremony, not a drain, not a tidy-up edit. The one agent write of it happens in the Owner's session, on his explicit instruction to commit (*The membership write* below). A document without the line has not been committed, whatever its timestamps say. The line is honour-system, because an agent can technically write it, so the prohibition is the control. Agent identity that would make it enforceable is APP-1619's territory, and it is not a precondition here. A cycle-membership write is *not* the marker, and neither is a comment reply or a marker ticket: membership writes are produced routinely by the delivery loop (a Forge format bounce drops membership, Relay's re-route restores it — A1-345, 2026-08-17 08:28, read as Owner approval and booked against), and Linear's boundary auto-transfer produces one at every boundary by construction (APP-1007). Aide (`skill-attention-sweep`/`task-aide-loop`/`assistant-aide`) tests this marker. A committed cycle whose goal document carries no `Committed by Aled — <date>` line, dated on or after the latest `[cycle-planning]` proposal comment, has not been approved this boundary, and Aide books nothing against it. A Friday proposal is two to three days old by Monday. Its age is not a staleness signal; only the missing line is (Owner decisions, Aled 2026-09-03 and 2026-09-21; APP-1567, APP-1577).

**The signal is load-bearing only while the membership write stays a human act (APP-820).** The freshness test works because the membership write is Aled's — a human approval that necessarily post-dates the proposal it approves. If the write were ever **delegated to an agent** (Atlas proposing a cycle and then writing its membership itself), the write would always follow the proposal automatically, the timestamp comparison would still return "fresh", and the signal would degrade into a tautology **while continuing to read healthy** — with no failing check anywhere. So cycle membership **remains a human write**; if it is ever delegated it must carry an **explicit approval marker an agent may set only on the Owner's instruction**, and Aide tests *that* marker instead of the timestamp. **That delegation is now in force, in exactly that shape (Owner, 2026-09-21, APP-1580).** The Owner's words were *"once I approve, it should be committed"*. That delegates the write to the agent in his session and nothing further. The agent applies the membership diff only on his explicit in-session instruction, and it writes the `Committed by Aled — <date>` marker in the same act. Aide tests the marker (APP-1567). This is the clause above taking effect, not a reversal of APP-429 / APP-629. No agent decides the week's scope, and the unattended scheduled ceremony still never writes membership. This is now a **stated dependency of Aide's correctness**, not merely propose-only governance: with APP-828's bounded auto-hold granted, nothing else stands between a stale-cycle read and a week of wrongly-booked holds — so the human-write constraint is a precondition of the freshness test, and the freshness test a precondition of the auto-hold grant. A later optimisation pass must not "helpfully" automate the membership write (Owner confirmed, 2026-08-14). Two clarifications keep this consistent with the marker above and with APP-1095. The Owner's approving write to the goal document records the goal **and the committed ticket list** — that list is what *planned* means for the cycle, and it is the list `skill-coordinate` diffs against each day. And `skill-coordinate`'s daily add-and-stamp — adding a started ticket that has no cycle to the current cycle and labelling it `cycle:unplanned` — is a membership write by an agent, but it is **not** a commit and is never read as one: the approval marker is the goal-document write, not membership, and the stamp exists precisely to mark the ticket as outside the commit (Owner decision, Aled 2026-09-03).

**The membership write — in session, on the Owner's instruction (APP-1580, 2026-09-21).** The approval arrives in a live session, such as Friday's `work.Planning` or a stand-up. In that session, and only on the Owner's explicit instruction to commit, do the following, in this order:

1. **Write the goal document.** Rewrite the body to the approved goal and committed list, remove the *proposed — not committed* markings, and add the `Committed by Aled — <YYYY-MM-DD>` line. Then append the open `planning-week` block (Step 1, *The planning-week record*), with `commit_ts` the time of the Owner's instruction to commit and `committed` the approved list, frozen. Read it back and parse it before step 2.
2. **Apply the approved diff to the opening cycle, by UUID.** Add each committed ticket, and never a `PUL-5E` note (APP-1038). Remove only the approved drops, and never strip a Done ticket (APP-585). A removal of a ticket the carry-over has not yet placed stays outstanding until after the boundary (Step 2).
3. **Read back each added ticket's cycle *and state*.** Committing a ticket to a cycle force-moves a backlog-type state (Backlog, Refinement) to **Todo**. The reverse also holds: moving a cycle ticket back to Backlog drops its cycle. So the write can land untriaged tickets in Todo. Report every Backlog/Refinement → Todo move by ID. Observed on the W39 write, 2026-09-21: seven tickets moved (A1-298, A1-393, A1-451, A1-452, APP-1302, MBN-301, MRP-56), five of them never triaged (APP-1581). This is observed platform behaviour, not a setting canon assumes can be changed.
4. **Diff the cycle's membership against the approved list, as a set.** Step 3 reads back the tickets that landed; a ticket that was never added is not in the set being read back, so no per-ticket check can see it. So after applying the diff, re-derive the opening cycle's membership **from the cycle** and compare it with the committed list in the goal document as two sets. Report every committed ticket whose `cycleId` is not the opening cycle's, by ID, as **not applied** — a different fact from *did not land*, which is a ticket that was in scope and did not finish. Re-derive from the cycle rather than re-reading the tickets the session believes it wrote: the failure being caught is a write that returns success and applies nothing, with `updatedAt` unmoved (`convention-linear`, *Writing Linear safely*; APP-1448, APP-1417), and a read scoped to the set the session believes it wrote inherits the same mistake. Where a ticket reads as not applied, retry it in a `cycle` write of its own, never bundled with another field — `cycle` is one of the params known to coerce or no-op when bundled (APP-1647) — and diff again. A ticket still not applied after one retry is reported, not retried a third time.
5. **Post `[cycle-planning] Membership applied — <n> added, <n> removed, <n> outstanding, <n> not applied`** as a comment on each team's goal document, naming any forced state moves and naming every not-applied ticket by ID. The fifth number is stated even when it is zero: a missing figure reads as a check that did not run, and this comment is the only record that the set-level diff happened. A non-zero count is carried into the boundary retro as **never scheduled**, not as *did not land* — the two have different remedies. The goal document's list is the definition of *planned* for every consumer (APP-1095), so a committed ticket outside the cycle is counted as planned by the document's readers and absent by the cycle's, `skill-coordinate` Pass 7 stamps nothing for it, and the unplanned share is inflated by the gap rather than by the work. (Worked case: the W39 Apps write of 2026-09-21 landed all five approved removals and ten of fourteen adds and posted its applied comment. APP-747, APP-1455, APP-681 and APP-982 still read `cycleId: none` five days later. Every per-ticket read-back passed, because the four missing tickets were never in the set read back, and the run that found them had to report four tickets under *did not land* that had never been in scope — APP-1786.)
6. **File each operator-addressed instruction as a ticket, in the same act.** An approved goal document routinely carries instructions addressed to a named `operator-<venture>` in its body prose — a priority raise, a re-route off the `human` lane, a pull-out-of-Backlog, a sequencing call. `convention-ticket`'s rule that every obligation is encoded as structure rather than prose binds here exactly as `convention-comms-owner` binds it to a *Forward* line: an instruction naming no ticket has one reader, the next weekly operator loop, so it expires with the cycle it was written for. So for each operator-addressed instruction in the committed document, file a small ticket in that vertical's home delivery team carrying `operator-<venture>` and **no executor**, titled with the instruction and naming both the goal document and the ticket it concerns, and list each by ID in the step 5 comment. The operator's daily pass reads the operator-routed queue first, so the lag drops from up to a full cycle to one day. This is a write of the Owner-approved set and nothing beyond it; the unattended Friday run files none of these. (Worked case: `a1.cycle-goal.2026-W41`, committed 2026-10-05, carried four instructions addressed to `operator-a1` — A1-583, A1-574, A1-537/538, A1-491. Twenty-four hours later A1-583, named in that same document as the goal's main deliverable, was still No priority carrying `human` and the Owner as assignee; all four were actioned only because that week's loop happened to fall there, and the lag would otherwise have been up to seven days — APP-2100.)

Without that instruction nothing is written, and the proposal stays awaiting approval. The scheduled run never does any of this, and neither does any other unattended run.

**An unapproved proposal becomes an open Owner decision on its second day — the ceremony states the date, and never waits quietly for it.** A proposal awaiting approval is *reported*, and nothing escalates it. That is how the first proposals on every team sat unapproved for a whole cycle while the one consumer that depends on them reported *no committed cycle* each day and correctly swept nothing: the freshness test worked, the gate held, and the silence was the defect. So two things change, neither touching the gate. First, each `[cycle-planning]` proposal states **its own escalation date in its closing line** — "Unapproved after `<YYYY-MM-DD>` (the second day), this proposal is an open Owner decision", where the date is the day after the proposal is posted. That gives every daily Owner-facing reader a dated, deterministic trigger in the document it already reads, where until now it had only the absence of an approval marker, which is indistinguishable from a proposal posted an hour ago. Second, on **any** later run of this ceremony, scheduled or on demand, **before proposing anything**: read each team's most recent cycle-goal document, and where it carries a proposal comment with **no `Committed by Aled — <date>` line dated on or after it**, name that team at the **head** of the run's output as an open Owner decision, with the proposal's date, its age in days and the cycle it governs — never as a quiet *no committed cycle* line further down among the caveats. Nothing else moves: the approval stays the Owner's, no agent writes the marker line outside his session, the unattended run still never writes cycle membership, and this ceremony still never approves its own proposal (APP-820, APP-987, APP-1580). All that changes is that an unapproved proposal stops being silent. (Worked case: on 2026-09-18, four days after cycle-planning went live, `apps`, `mbn` and `a1`.cycle-goal.2026-W38 all still read as verbatim `[cycle-planning]` proposals from 2026-09-14 with no goal write and no committed list, Mr Pritchard had no cycle-goal document at all, and no `*.cycle-goal.2026-W39` existed for the cycle covering the next working day — so `task-aide-loop`'s sweep → size → book loop had been structurally unable to run since the ceremony's first fire, with nothing escalating it and no failing check anywhere. W39 was committed on 2026-09-21, which closes that instance and not the gap: it recurs the next time a Friday proposal is not approved by Monday — APP-1546.)

**And the stated threshold names the surface that raises it, because a date addressed to nobody is not a trigger (APP-2698, APP-2685).** The paragraph above writes a dated, deterministic escalation into each proposal's closing line and says it gives every daily Owner-facing reader a trigger. It names no reader and binds no surface: the only raiser this ceremony names is **its own later run**, which is weekly. For a Friday proposal the threshold falls on the Saturday, so the named raiser cannot fire until up to six days after the date it is testing — and where the next boundary is the opening of the very cycle the proposal governs, the cycle starts first and the raise never happens at all. The threshold has then done nothing but record, inside the document, the date on which it stopped being true. So two things, neither touching the gate and neither chasing the approval. First, the proposal's closing line names **its raiser as well as its date** — "Unapproved after `<YYYY-MM-DD>` (the second day), this proposal is an open Owner decision, raised by `<surface>` from that date" — so the trigger is addressed, and where no surface is yet bound to raise it the line says that instead, which makes the gap legible in the document rather than only in this ceremony's behaviour. The surface to name is the **daily** consumer that already reads this document and the proposal's date: `skill-attention-sweep`'s uncommitted-proposal age report, which runs inside `task-aide-loop`'s end-of-day cadence and already computes the proposal's date, the whole days since it and the boundaries crossed, so the raise costs it no new read. **Binding that surface to the raise is a change to `skill-attention-sweep` and is not made by this ceremony** — what is written here is the named raiser in the line this ceremony itself writes. Second, **this ceremony's own run reports how long the threshold went unraised**, not merely that the proposal is unapproved: where it finds a proposal past its stated date, the head-of-output line names the threshold date, the whole days since it, and whether the proposal was raised as an open Owner decision on any daily surface inside that window — and where it was not, it says so in those terms. An unraised threshold then accumulates a count across boundaries instead of re-setting to a fresh quiet *no committed cycle* line each week. Nothing else moves: the approval stays the Owner's, no agent writes the marker line outside his session, and whether he commits is neither this ceremony's to decide nor its to chase beyond the raise. (Worked case, **reported** from the filing runs' reads and unverified here: all four `*.cycle-goal.2026-W44` documents were proposed on 2026-10-23, each carrying "Unapproved after 2026-10-24 (the second day), this proposal is an open Owner decision", and all four still read PROPOSED — NOT COMMITTED on 2026-10-26, the opening day of the cycle they govern and two days past their own stated threshold. The daily loop stopped with an empty booking envelope on all four teams and the freshness test worked exactly as written. One operator loop did raise it, on its own agenda, because it happened to have read the document — and nothing obliged it to, which is the gap rather than the remedy. Same shape as the W38 four-team stall and W40's — APP-1546, APP-1961, APP-2698, APP-2685.)

**And the proposal's own commit deadline is filed as structure at proposal time, not left as prose (APP-2711).** The closing line above states a date, and the document is that date's only reader. Every dated read that could catch it is keyed on a field the document does not carry: the daily pass's overdue read keys on `dueDate` across the operator's declared projects, the carry read on the executor label, and the scope and queue reads on `operator-<venture>`. So a proposal can run days past its own stated deadline, inside the very cycle it governs, with nothing surfacing it — and the first surface to read the line is the next weekly fire of this ceremony, which is the gap the paragraph above is already about. So in the same act that posts the proposal, **file one ticket** in the vertical's home delivery team: titled with the commit it is waiting on, naming the proposal document and the cycle it governs, carrying `human` and the vertical's `operator-<venture>` label and **no executor**, with its **`dueDate` set to the stated deadline** — the day after the proposal is posted. **Cancel it at the commit**, in the same act that writes the goal, so a committed cycle leaves no open row behind; where the proposal is superseded rather than committed, cancel it the same way and say which. The date-keyed overdue read then finds it on **day one**, on a read that already runs, with no new instrument and no new recipe. This is step 6's own obligation one level up: that step files each operator-addressed instruction inside a committed document as a ticket, on the ground that *"an instruction naming no ticket has one reader, the next weekly operator loop, so it expires with the cycle it was written for"* — and a document's own commit deadline is an obligation of exactly that shape, one level above the instructions the document carries. **Premise correction, carried because the note rests on it:** the note attributes that sentence to `convention-ticket`. It is not there — grepped live, `convention-ticket` returns 0 for *expires with the cycle* and 0 for `APP-2282` — and it is step 6 of this file, which is also where `APP-2282` sits. The rule is authored against the live location; the mis-attribution does not change it. **The alternative shape is not taken.** Adding a committed-header read of the current week's cycle-goal document to the daily pass's recipe would put this obligation in `skill-operating-loop` and lengthen a recipe that is already long, where filing the ticket reuses a read that already runs and puts the commitment where every other dated commitment lives. (Worked case, **reported** from the filing run's reads and unverified here: `a1.cycle-goal.2026-W44` still headed PROPOSED — NOT COMMITTED and closing *"Unapproved after 2026-10-24 (the second day), this proposal is an open Owner decision"*, read three days past its own stated deadline on day 2 of cycle 16's eight, with nothing having surfaced it and this weekly loop the first surface to read the line. Whether the other three teams' proposals were also uncommitted was not checked by that run, and this rule does not depend on it. **Observed live, not reported:** each dated read named above keys on a field this document does not carry, and step 6 carries verbatim the sentence the note cites — APP-2711.)

   **And that ticket is filed in an unstarted state, never left in the team's create-time default (`APP-3107`).** The instruction above fixes the title, the labels, the executor and the `dueDate` and leaves the state to the create default, which on every delivery team is `Backlog`. The dated reads that give this rule its whole warrant are scoped to started and unstarted states, so the instrument built to surface an uncommitted cycle on day one lands, filed exactly as specified, in the one state no brief reads — and it lands there silently, because the ticket is correct in every field the rule names. So pass the unstarted state (`Todo`) in the same create call: one clause, no new read, and no hand-correction for the next run to repeat. **One consequence, named so the clause is not written blind:** on Mr Pritchard the *Active issues & due date* automation adds a `Todo` ticket carrying a `dueDate` to the live cycle, so on that team this ceremony's own propose-only write produces a cycle membership change by automation rather than by the ceremony's hand (`APP-2271`, closed; `APP-2297`, the proposal to turn that automation off, Blocked and open). That is a known property of one team's configuration and is reported in the proposal comment, not a reason to leave the state unset. **And the `dueDate` falls on a weekday the Owner's cadence actually reaches**, because a deadline set for a Saturday is unmeetable by construction: no ceremony and no brief fires on it, so the date passes unread and the first run to see it is reading a date already behind it. Correct forward, never backward. (Worked case, **observed** on the board 2026-11-16: the 2026-W46 to W47 run filed `A1-995`, `APP-3106`, `MBN-352` and `MRP-120` into `Backlog` and moved all four to `Todo` by hand — four writes this rule does not ask for — and all four carry a `dueDate` of 2026-11-14, a Saturday, now two days lapsed and unread; `MRP-96`, due 2026-10-31, has sat in `Backlog` for its whole life, is sixteen days overdue and has been named by no brief — `APP-3107`.)


**And an uncommitted boundary that repeats is one item escalating, not a fresh finding each run (APP-1994).** The clause above names an unapproved proposal with its age in days, which is right for the first one and wrong for the third. W38/W39 (APP-1546), W40 (APP-1961) and W41 (APP-1994) were each re-derived from scratch and re-surfaced as new — three notes on one condition, which is the repeat-surfacing `convention-linear` (*Escalating a stalled decision item — by age, not repetition*) forbids and the age ladder exists to replace. So the head-of-output read also **counts**: before naming a team, read its prior cycle-goal documents backwards and state how many **consecutive** boundaries have closed carrying no `Committed by Aled — <date>` line — "W41, second consecutive uncommitted boundary on this team", never "W41 unapproved, 3 days" where it is in fact the third. From the **second** consecutive boundary the condition stops being a per-run report and becomes **one carried item**: surfaced once, on one ticket, climbing one rung per boundary per the ladder, with a later run adding dated evidence to that item rather than filing another note — which is also why the retro's capture searches the queue for a same-root note before filing. **The gate is untouched.** The approval stays the Owner's, no agent writes the marker line outside his session, and the unattended run still writes no cycle membership (APP-1567, APP-1580, APP-820). All that changes is that the count is stated, so a standing state cannot keep reading as a first occurrence. (Observed 2026-10-06: all four `*.cycle-goal.2026-W41` documents now head *✅ Committed by Aled — 2026-10-05*, which closes the W41 instance and not the gap — the count is the thing nothing was keeping. The next test is the W42 boundary.)

## Output — the commit proposal

```
[cycle-planning] Boundary — <team> — <closing cycle> to <opening cycle> — <date>

Retro (closing cycle):
  Committed: <n> | Completed (completedAt in-window): <n> (<ratio>%) | Milestones moved: <list> | Slipped: <list>
  Throughput read: batched <n> | unbatched <n> (drain set aside: <what/when>) — sizing on the lower
  Goal: <beats met>/<beats total> — <met / partial / missed / no-commit / zero-commit>; stretch: <met / not met / none>
  Say/do: <committed landed>/<committed> | Carry-over: <n>
  Unplanned goal-serving: <n> (<share>% of committed + unplanned) — basis project <n> / child <n> / relation <n>; commit_ts <exact / upper bound> — <steady / rising / falling against the prior boundary> | New work: <n>
  Owner dwell (goal-critical, in-window hours by state, Owner-lane Todo included): <ticket> — In Review <h> | Refinement <h> | Blocked <h> | Todo <h> | Backlog <h> (reported beside the total, not inside it — APP-2946); total <n> item-weeks (hours ÷ 168)
  Time: <n> completions | points by project: <list> | publish/PUL-5E share <n>% | goal-project share <n>%
  Membership check: enumerated <n> vs issueCountHistory <n> — <match / mismatch: missing IDs where nameable>
  Did not land:
    • <ticket> — <one-line reason>
  Aged WIP (open committed work, age since last state change — source: get_issue(fields: ["stateHistory"]), the open entry's startedAt, age = session clock minus it; never updatedAt, never the issue-level startedAt):
    • <lane> — open <n> | oldest <n> cycles | median <n> | unmoved a full cycle or more: <n>
    • Floors (no usable state history — age derived from due date / created / dated thread evidence): <ticket> — floor <n> cycles, or "none" — labelled as floors, excluded from the median and from the unmoved bucket
    • No threshold applied — the measure only, nothing gated on it this run (APP-1171)

Rollover (proposed — needs your decision):
  Carry:   <ticket> — <reason>
  Drop:    <ticket> — <reason>  (cancel — major, not applied)
  Backlog: <ticket> — <reason>

Proposed cycle goal (opening cycle — needs your decision):
  Goal: <one stated objective — and the venture it serves>
  Pass condition (numbered beats, each checkable on its own): 1. <beat>  2. <beat>  …
  Reserved WIP slots for goal work: <n> of <total>
  Stretch (named, no WIP slot until the required set is done): <list, or none>

Proposed commit (opening cycle — needs your decision):
  Drawn top-down by priority; sized to the lower throughput figure: ~<n> tickets (unbatched delivery ~<ratio>%)
  Grouped initiative → milestone → ticket. A capability milestone carries a status word, never a percentage: Linear's progress bar is weighted by estimate points, so unestimated Done tickets count as zero and a finished capability can read 0% — and a capability is done when its demo runs, so a percentage implies a precision the milestone does not carry. A dated kind carries its target date. Milestone kinds and their naming: convention-ticket. Capability kinds are how new projects are set up; an existing project keeps the kinds it has until Aled moves it, per project (Owner ruling, 2026-09-22 — APP-1658).

  <initiative>
    <capability milestone> — <unknown / shaping / building / verifying / done>
    <Enabling · <name>, or Gate · <name>> — <done / not done> · target <date> · <on track / N days over>
      <ticket> — <one line>
      <ticket> — <one line>
    No milestone — <n> tickets
      <ticket> — <one line>
  Left out to fit: <ticket> — <reason>

Capacity note:
  Aled-lane items in the proposed set: <n>; In Review awaiting him: <n>; Blocked on him: <n> (Aide sizes and books from this against the hold windows).

Goal document:
  <team>.cycle-goal.YYYY-Www — <created this run / already existed / not created: reason> — this proposal is posted as a comment on it
  planning-week record: <team> <week> closed in <team>.cycle-goal.<week> — <parsed on read-back / did not parse: reason / no goal document>

Nothing written — awaiting your approval to commit cycle membership.
```

**Two renderings of one commitment, not two documents.** The goal document is the Owner's approval surface, and the whole cycle stalls until he reads and agrees it — so a surface that is hard to scan is the binding constraint on the ceremony, not a presentation preference. The **document body is the Owner's rendering**: the goal, and the commit list grouped **initiative → milestone/phase → ticket** with each milestone's completion and target date on its own line. The `[cycle-planning]` **comment carries the granular detail** — the retro arithmetic, the rollover reasoning, provenance, defect cross-references. One commitment, rendered twice, with nothing to keep in sync: the body states what is being agreed and the comment states how it was arrived at. Grouping is not cosmetic — it is the structure the board already carries and a flat ranked list discards, and it makes the drift legible at approval time rather than a fortnight later in the retro, since an at-risk milestone surfaces on its own instead of reading as a peer of 21 other rows. Tickets carrying no milestone are grouped under a stated *No milestone* heading with their count, so the gap is visible to the Owner before he approves rather than inferred afterwards; admissibility of an unmilestoned ticket to the commit list is unchanged by this rule. (Owner ruling, Aled 2026-09-14: *"this isn't very human readable so maybe we need two versions … should group them by initiative, then the table outlines what phases or milestones we want to hit and then the ticket"*, on opening a 22-row flat table — APP-1460.)

## Composition gate — goal-review before the ceremony leans on it

`skill-goal-review`'s output is a retro input, relied on **only once it has produced a run of `[goal-review]` summaries** (`task-goal-review`, weekly on trial from 2026-07-21). Leaning on it before it has output would make the ceremony's first live run also its dependency's first live run — two untested things failing together, with no way to tell which broke (`APP-501`; `APP-630` gate). Until then, read goal-review where one exists and retro against milestone and initiative state otherwise. Confirm goal-review has a track record before relying on its output in a live boundary run.

## Relationship to skill-plan — shared reading, not shared behaviour

This ceremony and `skill-plan` overlap in **what they read** (outcome-initiatives, cycle state, the board) and in nothing else. `skill-plan` is the **weekly focus snapshot** — a different cadence and a different output (the ≤5 in-flight recommendation), and it currently works. This is the **boundary ceremony** — retro, rollover, and the next commit. Two artefacts by deliberate decision (Aled, 2026-07-21, `APP-429`). **`skill-plan` must not be edited under this work** — where the two read the same Linear objects that is shared reading, and it is read here as a gating input to the commit, nothing more.

## Guardrails

- **One goal per cycle, propose-only (APP-815).** Atlas proposes a single cycle goal alongside the commit; Aled approves it at the same gate as membership. Never one goal per team; stretch goals never take a reserved WIP slot until the required set is done; the capacity split is reserved WIP slots, never an a-priori percentage.
- **Throughput is `completedAt`-in-window, not the burn-up (APP-891).** Read throughput from the completions whose `completedAt` falls inside the cycle window; `completedIssueCountHistory` is the burn-up (`APP-585` protects it) and a different number with a different job. Report a batched and an unbatched figure and size the commit on the lower — never pick a bulk-close threshold. Whether Linear opens a cycle with already-Done work is platform behaviour canon cannot change; canon only declines to read it as throughput. Same undefined number drives both the overcommitment `APP-581` records and its mirror, undersizing a backfilled cycle.
- **The approval signal is the `Committed by Aled — <date>` line in the cycle-goal document (APP-820, APP-987, APP-1567).** Downstream consumers (Aide) test cycle freshness against that line, dated on or after the latest proposal comment. A goal document without it is stale, not approved. A timestamp or author read never counts, because every connector write authors as the Owner. No agent writes the line except in the Owner's session, on his explicit instruction to commit. A membership write never counts either: the delivery loop and the boundary auto-transfer produce those without any Owner act.
- **No goal document, no commit — and the ceremony says so rather than ending quietly (APP-1273).** The goal document is Step 4's first write, per team, created carrying the proposal and left for the Owner's commit write; a team that ends the run without one is named in the summary with its cycle and end date. Every downstream approval test — `skill-coordinate` Pass 7, `skill-attention-sweep`'s freshness read — is specified against that document, so its silent absence reads downstream as *nothing to do* rather than as *never committed*.
- **Propose-only on cycle membership.** Read cycles, draft a rollover, post a commit proposal. The scheduled, unattended ceremony never writes cycle membership: no add, remove, or move. The write happens only after Aled's explicit approval, in his session and on his instruction, carrying the approval marker, with each added ticket's state read back (APP-1580, APP-1581, 2026-09-21). Atlas proposes, Aled commits; autonomous commit was considered and rejected (`APP-429`, `APP-629`), because an agent deciding the Owner's week's scope is a larger grant than the delivery loop makes anywhere else.
- **The commit is drawn top-down by priority — never priority-blind.** The Priority Board (project rank) and the latest `skill-plan` focus output gate the commit; a cycle committed without them booked the wrong emphasis on day one (`APP-625`). Priority orders, the initiative-tie filters, throughput sizes.
- **Never remove a Done ticket from a cycle** — completion history depends on Done tickets staying in scope; only Canceled tickets are ever stripped (`APP-585`).
- **Resolve the cycle UUID; never trust the literal `"current"`** — an empty result is a "no active cycle" record for that team, not an error to work around (`APP-580`).
- **No boundary, no ceremony — and a boundary is the current cycle's `endsAt` within about 72 hours of the run (APP-1577).** The scheduled ceremony fires on Friday 16:00 Europe/London, before Linear's Sunday boundary, and it reads a cycle still in flight by design: closing = `current`, opening = `next`, and the retro is partial, *as of Fri 16:00*. An on-demand run after the boundary resolves `previous`/`current` and reads closed data. A scheduled fire with no team whose current cycle ends inside that horizon reports and stops (APP-1007).
- **Step 2 gates entry and reconciles the carry-over; it never writes either.** Cycle automation is off on the delivery teams, so entry is the commit; Linear's carry-over of incomplete issues still runs, so Drop and Return to Backlog are stated as "do not carry into cycle N+1" on the Friday run, and as proposed removals from the opening cycle on an on-demand run after the boundary (APP-1007, APP-1577).
- **An enumeration / count mismatch is a caveat, never a hard-fail.** Proceed, report the mismatch on the proposal with the missing IDs where nameable, and never infer absence from a cycle-scoped read (APP-890).
- **Planned is the committed list in the goal document; unplanned goal-serving work is derived from structure, never hand-labelled.** The retro reports the share per team each boundary from the derivation in Step 1, not from a `cycle:unplanned` count, and no step here asks the Owner to label anything (APP-1095, APP-2400).
- **The `planning-week` record is written twice and frozen between.** Open at the commit, in the Owner's session; closed at the first run after the cycle's `endsAt`. The committed list in it is never edited after the commit, and the close is the only body write after a document's create (Step 1, *The planning-week record*; APP-2400).
- Never marks Done, never cancels or defers a ticket autonomously — those are major moves, surfaced for Aled.
- Never writes code, never opens a branch or PR, never touches the Pipeline team. Delivery teams only (Apps, A1, MBN).
- Does not edit `skill-plan` — a sibling artefact, out of scope for changes; this ceremony reads its focus output, nothing more.
- The unattended run that posts the proposal never makes the resulting write. The write waits for Aled's explicit approval, and it is applied in his session, on his instruction (APP-1580).

## Setup

- A **scheduled task on the Cowork / connector surface** (Linear connector only — no repo, so it is a task on the connector surface, not a Claude Code routine). Its config is a thin loader carrying the canonical loader line in `core-operating-model` (*The loader line — one form*) and nothing else — behaviour changes are made here, never in the config.
- **Cadence:** weekly, **Friday 16:00 Europe/London**, inside `work.Planning` (Fri 16:00–17:00, `convention-hold-windows`), as a pre-boundary proposal for the next cycle. Linear's Sunday boundary is left untouched, and which team is at a boundary is still resolved from the cycle's `endsAt`, never assumed from the weekday (Owner decision, Aled 2026-09-21, APP-1577). The scheduled task carries `CRON_TZ=Europe/London 30 15 * * 5` — re-timed 2026-09-25, read from the live schedule store 2026-10-23, and firing about 15:42 Europe/London. **Every citation of this figure carries the date it was read, because the figure moves and this file does not.** A bare cron quoted in canon is stale by construction: this line read `0 16 * * 5` as of 2026-09-22, the trigger was re-timed three days later, and nothing in the file registered it — so for four weeks canon named a boundary the schedule had already moved, and no reader could tell that from the page. So the test is the read, not the quote: `skill-plan`'s Friday focus output must land before the **live** fire time rather than before a figure carried over from an earlier read, and where the schedule store cannot be read the value is written with the date and the surface it was last read from, never as a bare assertion. **And the stated cadence and the live trigger now disagree** — this bullet opens on *Friday 16:00* while the live trigger fires at 15:30 — which is recorded here and not resolved here, because the cadence is the Owner's to set.
- **Before it schedules a live boundary run:** run this ceremony once by hand against a real boundary, with Aled approving the resulting commit; and confirm `skill-goal-review` has a track record (*Composition gate*). The by-hand run was the W39 planning session on 2026-09-21: the Owner approved, and the commit was applied in session (APP-1580).

On finish, run `skill-ops-retro` capture on this run's friction: file a FRICTION note to the Pulse queue for the drain pass to assess.
