---
name: "skill-plan"
type: skill
description: Prioritisation and focus management for Aled's delivery teams. Use whenever running the plan routine, or when asked to curate the plan, review cycle health, or produce a focus recommendation. Reads goal-initiatives and ticket state across delivery teams, separates important work from urgent work, and makes autonomous hygiene writes (priority fixes, cycle membership, due dates at fix/minor level) while surfacing major restructuring proposals for Aled. Checks that the cycle it reads is genuinely live, not boundary-overdue, before planning against it. Runs ~weekly on the Linear connector. Never marks Done, never writes code, never touches Pipeline.
license: CC BY-NC-SA 4.0
---

# plan

The prioritisation and focus skill. Runs as a scheduled Cowork task on the Linear connector (Linear only — no GitHub). Follows `convention-linear` throughout.

## Trigger

Scheduled run ~weekly across all delivery projects: Apps (os.Claude, app.fitness, Luna MVP — Retirement Navigator, bot.Trader, and the careerOS projects cOS.System, cOS.Content, cOS.Build, cOS.App, cOS.Reporting), MBN (mbn.website, mbn.brand, mbn.growth), and A1 (all client projects). **Where this list and `convention-linear`'s team table disagree, the convention wins** — the team set changed on 2026-07-14 (careerOS demoted to projects under Apps, MBN promoted to its own team), and a scope list that predates a restructure misses a whole team's work silently, which is the one failure a sweep cannot report (APP-521, APP-550). **Mr Pritchard (`MRP`) is in scope**, named here rather than left to the deference rule to imply: it is a delivery vertical with its own operator, outcome-initiative and charter, and it runs cycles on the same Sunday boundary as the other three. Its editorial workflow states (`Defined`, `Ready`, `Scheduled`, `Published`) do not map onto three of this skill's checks — `agent:F0-RGE` WIP, starved queue, and the promotion flag — so **those three are skipped for MRP and the skip is reported**, never silently dropped; every other check, the cycle checks included, runs unchanged. `task-cycle-planning` settled the identical question the same way and for the same reason (APP-1383). Never touches the Pipeline team (Network / Roles / Advisory / Pitches) — that is the one exclusion.

Routine prompt: `Run the plan skill.`

## Cycles are in use — check per team, and keep the no-cycle fallback

The delivery teams **do** run Linear cycles. `APP-432` (*SETUP: enable cycles on careerOS / Apps / A1*) went Done on **2026-07-07**, and the weekly run of 2026-07-17 confirmed an active cycle 1 on all three teams — Apps, A1, and MBN. So the cycle passes in this skill are the **normal path**, not the exceptional one: read the active cycle, use cycle membership alongside milestone target and priority, and run the cycle-dependent hygiene.

**Resolve the cycle by ID, never by the literal `"current"`.** Call `list_cycles(teamId, type: "current")` first to get the cycle object and its real UUID, then pass *that UUID* to `list_issues`' `cycle` param. Passing the string `"current"` to `list_issues` silently returns zero issues for every team — no error — and a pass that trusted it would report a false negative on a genuinely committed cycle (see `convention-linear`, *Reading Linear safely*).

**A returned "current" cycle is not necessarily a live one — compare `endsAt` to today.** `list_cycles(teamId, type: "current")` keeps returning the last cycle as `isCurrent: true` after its end date has passed, so a team sitting at an unrolled boundary is indistinguishable from a team mid-cycle unless the dates are checked. Once the cycle is resolved, compare its `endsAt` against **today's date taken from the session clock**. Where `endsAt` has passed, the team has **no live committed cycle**, and it is handled exactly as the no-cycle case below: milestone + priority as the backbone, no cycle-dependent hygiene, and no burn reported as mid-flight status. Raise the boundary as a first-class health flag naming the cycle, its end date, how many days have lapsed, and whether a successor cycle is committed.

**The boundary is reported here, never run here.** `task-cycle-planning` owns the ceremony — the retro of the closing cycle, the rollover, and the next commit proposal. This skill states that the boundary is overdue and hands over; it does not retro a closed cycle, does not classify its incomplete work, and does not draft a commit. (Worked case: on 2026-08-10 all three delivery teams returned cycle 3, `endsAt` 2026-08-02, as `isCurrent: true` — eight days past its end, with no cycle 4 committed and the boundary ceremony not yet run. The run read that dead cycle as the live commitment and reported its burn as mid-flight cycle status. `APP-761`; ceremony epic `APP-429`.)

**Keep the emptiness check as a fallback, not as the expected case.** Before any cycle read, check, or write, confirm the team has an active cycle — a team can still be mid-boundary, newly created, or have cycles disabled. Where a team genuinely has none, skip that step for that team, treat milestone + priority as the backbone for it, and surface the state once (not per ticket) in the focus summary:

> `Cycles: live on <teams>; boundary overdue on <teams> (cycle N ended <date>); no active cycle on <teams> — milestone + priority backbone for those.`

The guard stays because it is what let this skill keep running correctly when the world changed underneath it; what changed is which branch is expected. (Worked case: this section asserted "no team runs cycles" for ten days after `APP-432` falsified it — the run stayed correct because it checks rather than trusts, but the canon misdescribed the world. `APP-585`, 2026-07-17.)

**When a setup ticket changes a fact this skill asserts, the assertion is what goes stale.** `APP-432` was setup work in a different lane from the canon that asserted the pre-setup state, and nothing connected them. Where a pass finds the workspace disagreeing with a factual claim written here, that is a `FRICTION:` capture, not something to work around silently.

## Behaviour

A run has four passes, executed in order.

### Pass 1 — Read the goals layer

Read all **outcome-initiatives** in Linear. These are the source of truth for prioritisation — the real goals, not just activity. For each initiative, note: name, current status, associated tickets, and any milestone targets.

**If no outcome-initiatives exist:** do not proceed with goals-based prioritisation. Instead:
1. Note the gap in the focus summary: "No outcome-initiatives found — prioritising by milestone target + priority only. To enable goals-based prioritisation, create Linear initiatives representing desired outcomes (not team mirrors)."
2. Fall back to milestone-target + raw-priority mode for the rest of the run.
3. Leave a comment on the os.Claude project or create an issue in Backlog (@mention Aled) flagging that outcome-initiatives need creating before goals-based prioritisation can run.

### Pass 2 — Read the board

For each delivery team, read all open tickets (Backlog through In Review; Done/Canceled excluded):

- Priority (Urgent/High/Medium/Low/None)
- Due date and milestone target
- Cycle membership (current cycle vs. none) — **only where the team has a live cycle**
- State (Todo, In Progress, In Review, Blocked, Refinement)
- Labels (agent group, type, work)
- Blocked-by relations (any still-open blockers)

**Exclude `agent:PUL-5E` canon-intake from delivery scope.** A ticket carrying `agent:PUL-5E` — a `FRICTION:` note or any canon-change intake — is propose-only intake for the Pulse retro drain, never delivery-loop work (`convention-linear`, *The Pulse friction queue*). It never joins a committed cycle, so counting it as cycle scope inflates scope and burn against work the loop will never complete. Drop `PUL-5E` tickets from the board read, the cycle-membership picture, and every cycle-health computation (`APP-870`).

**Also read:**
- Current cycle for each team (`list_cycles(teamId, type:current)`): its start/end dates, scope, completed count, and current membership. **Resolve the cycle UUID here and pass that ID to any `list_issues(cycle: …)` call — never the literal `"current"`.** If the call returns empty, record "no active cycle" for that team and skip the cycle-dependent steps below — do not treat the empty result as an error. **Then check `endsAt` against today before using the cycle for anything.** A cycle whose end date has passed is recorded as *boundary overdue*, not as the live commitment: skip the same cycle-dependent steps, note whether a successor cycle exists (`list_cycles(teamId, type:"next")`), and carry the finding into the health flags (`APP-761`).
- **Each delivery project's status header** (`statusType`) — needed for the not-started-but-full health check in Pass 3. The projects are already enumerated for the per-team board read, so reading the header here costs no extra sweep.
- Any recent skill-daily-report output (from comments or attachments on a dedicated skill-daily-report issue if one exists), to inform the urgency picture.

### Pass 3 — Analyse

#### Importance vs urgency

Separate the two axes:

- **Important** — aligns to a goal-initiative or a near-term milestone. A high-priority ticket that doesn't map to any active initiative or milestone is not necessarily important — it may be drifted.
- **Urgent** — time-sensitive, a blocker for other work, or has a hard due date approaching within the week (or the cycle, where one runs).

Produce a **focus recommendation**: the small set (aim for ≤5) that should be in flight now — highest-importance and highest-urgency combined, respecting the lane separation:

- Claude Code (F0-RGE) lane: serial per repo — recommend the next eligible ticket per repo.
- Aled's lane: decisions, reviews, merges — the specific actions Aled needs to take this week.

**Promotion flag (Aled's gate):** when a milestone's `agent:F0-RGE` work sits in Refinement with nothing promoted to Todo, the delivery loop is idle for that repo. Plan cannot promote (Todo is Aled's gate), so surface a milestone-scoped "promote next N to Todo" proposal naming the specific tickets — a standard plan output whenever a repo's queue is starved. (Worked case: ~45 Luna F0-RGE tickets in Refinement, loop idle, 2026-06-29.)

#### Health checks

Flag these as findings (to write or surface, per the autonomy model):

- **Boundary overdue** *(only where the team runs cycles)*: the resolved "current" cycle has an `endsAt` in the past. Report it as `cycle N ended <date>, N days ago — no cycle N+1 committed; boundary ceremony has not run`, and hand to `task-cycle-planning`. This is a finding, not a licence to run the ceremony here, and the team's other findings are computed on the milestone + priority backbone for that run.
- **Cycle uncommitted** *(only where the team has a live cycle)*: the cycle resolves, its `endsAt` is in the future, and **no** `<team>.cycle-goal.YYYY-Www` **document exists for it** — or one exists carrying no Owner write later than its latest `[cycle-planning]` proposal comment. Report it as `cycle N is live to <date> but was never committed — no goal document, so no committed list and nothing to measure delivery against`, and hand to `task-cycle-planning`, exactly as for a boundary overdue. This is the mirror of that flag and the worse of the two to miss: an overdue boundary is visibly stuck, whereas an uncommitted cycle passes every other check in this skill — it resolves by UUID, its end date is ahead, the fallback branch is not taken — and reads as entirely healthy. **Raising it is not the same as skipping a computation.** The *unplanned share rising* check below correctly declines to compute where no goal document exists; that instruction tells the run to skip a number, and a run following it to the letter skips the number, reports the cycle live, and never says the ceremony did not run. Search on the shared `cycle-goal` segment, never on a prefix (`convention-linear`, *Documents and the decision log*). (Worked case: 2026-09-14 — cycle 10 opened cleanly on Apps, A1 and MBN, `list_documents(query: "cycle-goal")` returned zero workspace-wide, and the prescribed summary line would have read `Cycles: live on Apps, A1, MBN — cycle 10, ends 2026-09-20` with nothing said. APP-1420; the burn-up then measures throughput rather than delivery against a plan, compounded by intake entering the cycle on completion — APP-1007, APP-1425.) **Uncommitted is judged against the ceremony's fire for the cycle, not against the cycle's start.** The ceremony's first write is the goal document (`task-cycle-planning`, *Write the goal document before posting anything*). So a missing document is a finding only once that ceremony's scheduled fire for this cycle has passed. While the fire is still ahead of this snapshot, the absence is expected, and the line reads `cycle N — commit pending: the ceremony for it is due after this snapshot`, not "never committed". The plan-first order is intended and is not a defect to re-time. This snapshot is a gating input the ceremony reads (*Focus summary*; `task-cycle-planning`, *Drawn top-down by priority*), so it runs before the ceremony by design and cannot see the proposal it feeds. This skill has no scheduler read, so the ceremony's fire time is taken from the schedule recorded here and re-checked whenever that schedule moves. (Observed 2026-09-22: `task-plan` fires Mon 05:30 UTC. `task-cycle-planning` fired Mon 06:30 UTC until 2026-09-21 and is now Fri 16:00 Europe/London, APP-1577. Under the Monday schedule this check fired falsely on every snapshot. The 2026-09-14 worked case above was itself taken before the ceremony: the W38 goal documents were created at 06:40–06:41Z, after that morning's snapshot, and the W39 documents at 06:36–06:38Z on 2026-09-21, after the 05:33Z snapshot. Under the Friday schedule, a Monday snapshot follows its cycle's ceremony, so a missing document on a Monday is a real finding again, and so is a document with no Owner write after the proposal. APP-1562, 2026-09-22.) **And a Monday snapshot is taken before the Owner's commit lands, so the second limb needs the same two-state treatment as the first.** The ceremony writes the goal document on the Friday, the Owner's commit write is observed mid-morning on the Monday, and this snapshot is taken at ~05:30Z — so a document carrying no Owner write later than its proposal comment is, on a Monday, indistinguishable between about to be committed and never committed, and the flag fires on both. Where the only missing signal is the Owner write and the snapshot precedes the observed commit window, the line reads `cycle N — commit pending: the goal document exists and the Owner's commit for it is due after this snapshot`, never "never committed"; after that window it is a real finding again. Report the measurement rather than the verdict either way — `uncommitted as of <snapshot time>; the previous cycle was committed at <time> on the equivalent day` — so no downstream reader can promote a two-hour lag to a standing failure. (Worked case: all four W42 goal documents read `createdAt == updatedAt` at the 2026-10-12 05:35Z snapshot and the flag fired on all four teams, the fourth consecutive Monday; the W41 documents gave the identical reading at the 2026-10-05 05:39Z snapshot and were committed about 2h20m later the same morning. The false reading propagates as fact — the `a1.standup` note of APP-2136 asserted two cycles uncommitted three days after both were committed. Whether `task-plan` should instead run behind the commit window is APP-1787's question and is assessed with it, not here — APP-2264.)
**And the cycle-uncommitted test reads the dated per-team COMMIT ticket as its decisive signal, not the goal-document comment (`APP-2802`).** The bullet above rests the whole test on the goal document — its existence, and whether it carries an Owner write later than its latest `[cycle-planning]` proposal comment — which is the **ambiguous** signal, as that bullet's own two-state carve-outs for a Monday snapshot concede: it cannot tell *about to be committed* from *never committed* and so fires on both. A decisive signal now exists and the test never mentions it. The planning ceremony files **one dated COMMIT ticket per team** in the same act that posts the proposal — naming the proposal document and the cycle it governs, carrying `human` and the vertical's `operator-<venture>` label, with its `dueDate` set to the stated commit deadline — and cancels it at the commit (`task-cycle-planning`, *the proposal's own commit deadline is filed as structure at proposal time*). That ticket answers the question this test is actually asking, and answers it off a date-keyed read rather than off an inference about write ordering: an **open** COMMIT ticket past its due date is an uncommitted cycle, and a **cancelled** one is a committed cycle whatever the goal document's timestamps read. So the rule is categorical: **read the dated per-team COMMIT ticket as the decisive signal; fall back to the goal-document comment only where no COMMIT ticket exists for that team's cycle; and say in the reported line which of the two signals was read.** A line that reports a cycle uncommitted without naming the signal it read is not reportable, because the two signals carry different error modes and a downstream reader cannot tell which one it is being handed. Nothing else in the bullet moves — the ceremony-fire timing rule, the two-state *commit pending* wording and the shared-segment document search all stand, and the fallback branch is where they continue to apply. (Worked case, **observed** as of 2026-11-03: the four COMMIT asks `APP-2793`, `A1-845`, `MBN-344` and `MRP-96` are all **3 days past** their **2026-10-31** due dates — **observed** — and the cycle has gone **two consecutive boundaries** uncommitted — **observed**. Read off the COMMIT tickets the finding is a dated overdue row on four teams at once; read off the goal documents it is the same ambiguous timestamp reading that produced four consecutive false Mondays, which is why the decisive signal is made the primary one and the document the fallback.)

**And a cancelled COMMIT ticket is read for its disposition, because the cancel carries two meanings and only one of them is a commitment (`APP-3114`).** The rule above makes the cancelled limb decisive on `status` alone, and that limb is the one place the instrument inherits an ambiguity of its own: a COMMIT ask is cancelled **at the commit**, because the approval landed and the ask is discharged, or **after the boundary**, because the cycle closed unapproved and carrying two live asks for two cycles is worse. Both render identically on a compact `fields` read — `status: Canceled`, no due-date change — and the error runs in the direction that reads as health, reporting a commitment that never happened and shortening the uncommitted streak by one boundary and one team. The meaning is already written down: `task-cycle-planning` files the ask with a disposition instruction obliging the closer to *"cancel it the same way and say which"*, so the closer's own closing comment holds the answer and this test simply does not look. So the rule for the cancelled limb is: **read the closing comment on each cancelled COMMIT ticket with `list_comments` at `limit: 10` before scoring it**, treat *cancelled at the commit* as committed and *cancelled as superseded* as **uncommitted**, and where no comment states which, report the cycle **uncommitted with the disposition unread** rather than committed. The reportable line then owes the disposition as well as the signal — *"committed (cancel at commit)"* and *"uncommitted (cancel as superseded)"* are different findings and a reader cannot tell them apart otherwise. The cost is bounded by construction: at most one comment read per team per run, four on this board, and only on the cancelled limb — the open limb stays the pure date-keyed read with no comment read at all, which is what `APP-2802` bought. The two rejected shapes are rejected on canon's own lean: making the disposition structural — a `cycle:committed` / `cycle:superseded` label, or Done-versus-Canceled as the two dispositions — is a write-side change to `task-cycle-planning` and to every ask already closed, and dating the cancel against the cycle's `endsAt` is an inference about timing, which is the class of reasoning `APP-2802` moved away from. (Worked case, **observed** on the 2026-11-16 run and re-read **observed** 2026-11-17: `MBN-344`, *COMMIT: approve mbn.cycle-goal.2026-W45 — cycle 17*, is **Canceled**, cancelled a day after cycle 17 closed on 2026-11-09, and its closing comment of 2026-11-10T08:27:38Z reads *"Closed as Canceled — superseded. Cycle 17 (W45) ended 2026-11-09 with the approval never given"* — so the cancel marked abandonment, not commitment. Scored on `status` alone the run reports **three** consecutive uncommitted boundaries on three teams; read for the disposition it is **four** consecutive boundaries on all four teams, W44 through W47 — `APP-3114`.)

- **Overcommitted cycle** *(only where the team has a live cycle)*: more than a sensible number of tickets in the current cycle with no realistic chance of completion. Never compute this against a boundary-overdue cycle — a dead cycle's residual open scope is rollover, not overcommitment.
- **Unplanned share rising** *(only where the team has a live, committed cycle)*: the share of the current cycle's membership carrying `cycle:unplanned` — derived daily by `skill-coordinate` from the cycle-goal document's committed list, never hand-labelled (`convention-linear` *Labels*, APP-1095). Report the count and share, and flag it where it is rising against the previous cycle's boundary read (`task-cycle-planning` reports the closing share each boundary). Read it as a **planning** signal, not a delivery one: a rising share says the commit is not foreseeing the week's work, not that the fleet is slow — so the recommendation points at the next commit (size, scope, what keeps arriving unplanned), never at the tickets themselves. Never compute it where no goal document exists for the cycle; there is no committed list to be unplanned against.
- **Stale Urgent:** a ticket marked Urgent that hasn't moved in >3 days and is not actively being worked. Priority may have drifted.
- **Priority without milestone:** High/Urgent ticket with no milestone and no active blocked-by — candidate for milestone assignment or deprioritisation.
- **WIP violation:** more than one Forge ticket In Progress in the same repo. Flag by name — this is a rule violation.
- **Blocked tickets:** tickets in Blocked state that haven't been touched in >2 days. Surface to Aled. **Exclude `agent:PUL-5E` notes** — a canon-decision note deliberately rests in Blocked (often Blocked + Urgent) as `skill-ops-retro`'s Owner-surface for a decision awaiting Aled, so it is resting by design, not a stalled blocker. Excluding it from this check is the fix, not stopping the Blocked surface Pulse relies on (`APP-870`).
- **Starved queue:** a repo with `agent:F0-RGE` work parked in Refinement and nothing in Todo — pair with the promotion-flag proposal above.
- **Queue populated but unreachable** *(per agent lane)*: a lane holding tickets in Todo with nothing in any started state, where some share of that Todo population sits in projects whose `statusType` is not `started`. Report the lane, the **reachable** count, the **unreachable** count, and the parked projects holding the remainder. This is a third flag rather than a correction to either check above, because those two test a different transition: the starved-queue bullet and the promotion-flag proposal both key on **Refinement → Todo**, which is Aled's promotion gate, while the condition that stops a lane delivering is the next one along — **Todo → dispatch, gated by the project's own liveness**. `convention-linear` fixes that gate in canon — *"Coordinate, plan and the daily report all gate on project liveness (`statusType == started`)"*, and *"A parked project's ticket returns when the project restarts"* — and `Hold` sits under the `planned` type, so a lane whose Todo population sits behind `Hold` is undispatchable while reading clean on the starved queue (there is plenty in Todo), clean on the promotion flag (for the same reason), and clean on WIP violation (there is no WIP to violate). The failure is therefore self-concealing in the direction that reads as health: a run follows canon exactly and says nothing about a lane that moved nothing all week, so this flag is the prescribed line it would otherwise not have. The test costs no extra read — Pass 2 already holds every delivery project's status header (the not-started-but-full check requires it) and every ticket's project and agent label, so the predicate is a client-side join of two readings already in hand. Pair it with the *parked project holding live tickets* finding above rather than reporting the same inventory twice: that finding enumerates the same projects from the project's side, this one from the lane's. (Worked case: the 2026-11-09 focus pass found zero `agent:F0-RGE` tickets in any started state workspace-wide against ~18 in Todo, twelve of them inside `Hold` projects — `app.Luna`, `bot.Trader-B`, `cOS.Build` — and all three existing checks reported clean on a lane that had delivered nothing; those are that run's own first-hand figures, not re-read here, and this flag states a predicate rather than any of them — `APP-2953`.)
- **Project not-started-but-full** *(project-status hygiene)*: a delivery project whose `statusType` is `backlog` or `planned` (it still reads e.g. `Backlog`) that nonetheless holds any ticket in a `started` or `unstarted` state — a stale board signal, not a considered park. Surface it as a **major-level** proposal to correct the project to **In Progress**; never auto-write project status, since `statusType == started` gates every liveness-scoped sweep (`skill-coordinate`, `task-daily-report`, `skill-fleet-dispatch`) and rerouting it silently reroutes them all. The test costs no extra read — Pass 2 already holds the project headers and the ticket movement. This is the *not-started-but-full* mirror of the started-but-empty check; `convention-project-status` describes the case and names this skill as its surfacer (`APP-893`). **`Hold` is excluded from this check, and the Hold case is its own finding.** `Hold` sits under the `planned` type, so the predicate as written matches every deliberately parked project still holding a live ticket, and the prescribed remedy would un-park a bet the Owner parked. Exclude `Hold` here and report a parked project holding `started` or `unstarted` tickets as a separate minor-level finding — parked project holding live tickets: dispose of the tickets, do not start the project — naming the tickets so they can be closed or re-parked (`convention-project-status`). (Worked case: on 2026-10-12 the literal predicate matched twelve projects rather than five, the seven extra all on Hold with live tickets, and the exclusion was re-derived from precedent as it had been the week before — APP-2265.) **The same exclusion is needed at the `backlog` end, and the two together are this check's exception set rather than two separate patches.** `Hold` is the `planned`-end case of a status that is a considered position rather than a stale signal; the `backlog`-end case is a **pre-commitment** project — speculative work held against an outcome nobody has committed to yet. So exclude from the In Progress proposal, by name and not by inference, any matching project whose **parent initiative's status is not Active** — Proposed, Paused, Completed or Canceled — and report it instead as its own **minor-level** finding: *pre-commitment project holding a ticket; confirm the park or start the project*, naming the project, the ticket and the initiative's status so the Owner can settle it either way. The test costs one field: Pass 2 already holds each delivery project's status header, and the initiative status is one read on its parent. **The predicate itself stays exactly as written** — it is not wrong, it is under-specified, and these two are the conditions under which its remedy is the wrong one rather than corrections to its match condition. Read any further deliberate-park shape as a member of this same set rather than as a third special case: the distinction the whole check rests on is `convention-project-status`'s — *a project with work underway that still reads Backlog is a stale board signal, not a considered position* — and a status that is deliberate at either end fails that test the same way. Starting a pre-commitment project does the harm un-parking a `Hold` does, for the same reason: `statusType == started` gates every liveness-scoped sweep, so the project's speculative inventory enters `skill-coordinate`, `task-daily-report` and `skill-fleet-dispatch` for an outcome that may never be won. (Worked case: the 2026-10-26 focus pass matched `Bang Bang City · Site & collective` — `statusType: backlog`, holding A1-717 at Todo and Low, raised explicitly as pre-commitment — under `a1.BangBangCity` (I-24), the one initiative in the workspace reading **Proposed** rather than Active. The same run's other two matches, `a1.OS` and `Substack`, were genuine stale-status cases and the standing remedy was right for both, which is the argument for an exception rather than a rewrite. The run derived the exclusion by hand from the initiative's status and the ticket's framing, as the `Hold` end was derived by hand before it was written down. One instance — APP-2667, the `backlog`-end mirror of APP-2265's `planned`-end exclusion; APP-2415 is a third hand-repair of this same predicate, on which artefact owns the computation rather than on what it matches, which is why the exceptions are named here as a closed set. The project's status, the ticket's priority and framing, and the initiative's status are the filing run's read and are not re-read here.)

### Pass 4 — Write and surface

Apply the **major/minor/fix autonomy model** (from Aled's direction, 2026-06-10):

**Fix-level (apply autonomously, comment to note):**
- Remove **Canceled** tickets from the active cycle (they inflate scope without ever completing) — only where the team has a live cycle. **Never remove Done tickets from the active cycle.** Linear's cycle completion metric *is* the count of completed issues in scope (`completedIssueCountHistory` against `issueCountHistory`), so stripping Done tickets out drives the completion rate toward zero and destroys the burn-up — the write done for "cycle health" would be the thing that wrecks it. (Apps cycle 1 read 55 completed of 74 scope on 2026-07-17; applying the old instruction literally would have left it reading 0 of 19. `APP-585`.)
- Add a due-date to a ticket when the milestone target is clear and the ticket has none.
- Correct a clear label inconsistency (e.g. a ticket at Urgent that was just unblocked and set Urgent as the "visibility flag" — lower back to its pre-block priority per the convention).

**Minor-level (apply autonomously, comment to note):**
- Adjust priority one step when milestone proximity clearly warrants it (e.g. a Medium ticket that blocks a High ticket due this cycle → promote to High).
- Add an unscheduled ticket to the current cycle when it fits within capacity and aligns to an active goal-initiative — **only where the team has a live cycle**. Never add work to a boundary-overdue cycle: membership of the next cycle is the ceremony's proposal and Aled's gate.
- Set a due date that follows directly from a milestone end date with reasonable lead time.

**Major-level (surface to Aled, do not apply):**
- Restructuring multiple tickets' priorities (changing focus direction).
- Recommending to cancel or defer a milestone.
- Recommending to cancel or deprioritise Urgent tickets.
- A milestone-scoped "promote next N to Todo" recommendation when a repo's queue is starved.
- Any change that would substantially reroute the agent queue or Aled's attention.

For major findings, post a comment on the relevant ticket or project @mentioning Aled (`@aledpritchard`), stating the recommendation and the reason. **Do not apply** — the proposal is the deliverable, on every surface. **Then assign by surface, because most major findings do not land on an ordinary ticket:**

- **A ticket** — assign Aled. This is the only case where the assignment is a write that exists, and it is what puts the proposal on his assigned-to-me view.
- **A project or a document** — comment and @mention, and **do not assign: neither carries an assignee field.** The absence is not a deviation and is not recorded as one each run. This pass's own checks produce findings of exactly that shape — *project not-started-but-full* is defined on the project header; *cycle uncommitted* and *boundary overdue* are reported against the cycle-goal document — so it is the common case, not the exception.
- **A ticket whose lane forbids an assignee** — a Forge ticket resting in Todo is unassigned by `convention-linear`, and that stands. Comment and @mention, leave it unassigned, and name the lane in the comment as the reason. Assigning it would break the very convention the proposal is usually about.

(Worked case: the 2026-09-28 focus pass produced five major proposals and could honour "Assign Aled" on **one** — the other four were four `*.cycle-goal.2026-W40` documents, two projects, and APP-1600, an `agent:F0-RGE` ticket in Todo. Three defensible readings and no tiebreak, re-derived every run — APP-1805.)

## Focus summary

At the end of each run, file the summary as the **weekly focus snapshot** — a single named Linear **document**, replaced in place each run (not appended), in the delivery team's operations/planning project (the same documents store the decision log and the per-cycle cycle-goal document live in), under a fixed, type-prefixed title (`osclaude.focus-snapshot`, "Weekly focus snapshot") per `convention-linear`'s document-filing conventions. One named document that downstream consumers fetch **by name** — not a comment posted to the os.Claude project that readers must search for — is what lets `task-cycle-planning` Step 3 read this as a gating input to the commit; the write path here and that read path were aligned on 2026-08-15 (`APP-892`). It is a document, not an issue, so it never sits inside a cycle as scope. The summary is the deliverable Aled reads ~weekly:

```
[plan] Focus — <date>

Goal-initiatives: <n found> | <list names>
Cycles: <live on teams — cycle N, ends date | boundary overdue on teams — cycle N ended date, N days ago | no active cycle — milestone + priority backbone>

In-flight now (F0-RGE):
• <repo>: <ticket> — <why it's the right next>

In-flight now (Aled):
• <action 1>
• <action 2>

This week's focus (important × urgent):
1. <ticket> — <one-line rationale>
2. <ticket> — ...
...

Health flags:
⚠️ <flag> — <one-line>

Writes applied this run:
✅ <fix/minor write applied> — <one-line>
⊘ <branch tested, no write> — <the one reason it declined>  [list every branch when none applied, and name the previous snapshot's count]

Proposals (needs your decision):
❓ <major recommendation> — <link>
```

Keep the summary scannable. Aled reads it at his weekly review, not in a linear triage session.

**Date the summary from the session clock, and judge every deadline against that date.** Take today's date from the run's own clock. Never infer it from a cycle's end date, a milestone target, or a date quoted in a ticket title — data-derived dates are systematically stale, and a summary that dates itself wrong frames everything downstream wrong: a lapsed cycle reads as mid-flight and a target that has already passed reads as imminent. (Worked case: the 2026-08-10 run's first draft took its date from the closed cycle's end and from the `MBN-261` title's "2026-08-01 target", dated itself 2026-07-31, and described a target nine days past as "tomorrow"; caught only by the posted comment's own `createdAt`, then corrected in place. Same root cause as the boundary-overdue miss above — `APP-761`.)

**A run that applied no writes says so with its declines, because an empty list and a closed write surface read identically.** *Writes applied this run* is a list of writes, so a run that made none renders as an empty section — the same output a run would produce on a board that needed nothing. Those are two different findings, and the second is the one worth reading, because the fix and minor branches are specified against a healthy board: they assume a committed cycle, live milestone targets, and a population of agent-routable tickets with drifting metadata. An uncommitted boundary, a board past most of its dates, or a `human`-saturated cycle membership therefore closes several branches at once and narrows this skill to reporting at the point where a write would matter most — and each individual decline is correct while the set of them is the finding. So where a run applies no writes, the section is not left empty. It names **each branch it tested and the one reason that branch declined**, one line per branch, and it names whether the snapshot it is replacing also applied none — `no writes applied; previous run 2026-09-28 also none` — so that a run of zero-write runs is legible from the snapshot itself rather than only from whichever run happened to spell its declines out longhand. The declines are this run's output in that state; they are neither a confession nor padding. (Worked case: the 2026-09-28 and 2026-10-05 runs applied zero writes each — three declines, then six — every decline traceable to canon, and the two runs reached the same verdicts independently, which is evidence the reasoning is stable rather than ad hoc. The cycle-membership write, the one branch that could change what the week delivers, is unavailable by definition in exactly the state that needs it, because membership *is* the commit and the commit is the Owner's gate (`APP-1580`); both due-date branches were closed by targets that had already passed rather than by missing data (`APP-761`); the Canceled-member strip found nothing on any of the four teams twice running; and the priority branch's one live candidate was forbidden by its own ticket. None of that was legible from the summary format — `APP-2026`.)

## Guardrails

- Never marks Done. Done is Aled's gate; merge acts only on his explicit approval signal.
- Never writes code and never opens a branch or PR.
- Never touches the Pipeline team (Network / Roles / Advisory / Pitches).
- Never autonomously cancels or Dones a ticket — surface it as a major proposal.
- Does not run inside an exec session — it reads tickets In Progress but does not claim or modify them.
- Cycle passes run by default (cycles are live on Apps, A1, MBN since 2026-07-07) but stay guarded — confirm the team has an active cycle before any cycle read, check, or write, and surface a team with none once rather than no-opping silently.
- **Never treat a boundary-overdue cycle as live.** Compare the resolved cycle's `endsAt` to today's date from the session clock; where it has passed, the team has no live commitment — fall back to the milestone + priority backbone, apply no cycle writes, and flag the boundary (`APP-761`).
- **Reports the boundary, never runs it.** The retro, the rollover, and the next cycle's commit belong to `task-cycle-planning` (`APP-429`). This skill names the overdue boundary and hands over; duplicating the ceremony here would put two artefacts in charge of the same decision.
- Never remove a Done ticket from a cycle. Cycle completion history depends on Done tickets staying in scope; only Canceled tickets are stripped.
- Fix/minor writes are applied in the same run; they are never batched silently. Always comment what was written.
- Major proposals are never applied in the same run as the proposal. Always wait for Aled's explicit approval in a comment.

## Setup

- Deployed as a **Cowork scheduled task** (cloud) via a loader config — `task-plan` reads this skill. Connector: Linear only.
- Cadence: ~weekly (or on-demand when Aled asks for a prioritisation review).
- Routine prompt: `Run the plan skill.`

> **Prerequisites:** outcome-initiatives must exist in Linear before goals-based prioritisation can run. If they don't, Pass 1 creates a flagging issue and the run continues in milestone-priority fallback mode. Aled creates initiatives; plan reads them. Cycles are live on the delivery teams since 2026-07-07 (`APP-432`); the run still checks per team — for an active cycle, and for that cycle being genuinely in flight rather than boundary-overdue — and falls back to milestone + priority for any team without a live one.

On finish, run skill-ops-retro capture on this run's friction: **search the Pulse queue first and add the evidence to a same-root note if one exists, otherwise file a new FRICTION note** for the drain pass to assess, in capture step 3's literal shape — team Apps, project os.Claude, `FRICTION:` title, labels `task` + `work:configuration` + `PUL-5E`, Backlog, unassigned — filing the friction, never the run report.
