---
name: "skill-attention-sweep"
type: skill
description: Sweep the committed cycle for everything that needs Aled and size it. Use this whenever running the Aide attention sweep, or when Aled asks what in the current cycle needs him. Reads the upcoming/committed cycle across the delivery projects (read-only), finds the items needing him — assigned to him, human-lane, awaiting his review or approval, or an open decision — classifies each and sizes it into 15m/30m/1h/2h, routing anything over 2h to Relay to split. Produces the classified, sized list that skill-time-plan allocates and skill-time-block books, and emits the weekly operator-scoreboard snapshot (APP-575) as a by-product. Never re-prioritises, never books calendar; its Linear writes are the estimate field on the items it sizes, plus the executor relabel and decomposition brief on an item its own sizing put over 2h (APP-1003, APP-2279).
license: CC BY-NC-SA 4.0
---

# attention-sweep

The read-and-classify half of Aide. It sweeps the **committed cycle** for everything that needs Aled, works out what kind of attention each item wants, and sizes it — so the rest of Aide (`skill-time-plan` to allocate, `skill-time-block` to book) has a clean, sized worklist rather than the whole board. It is read-only on Linear, one field excepted: it schedules Aled's attention, it never re-prioritises the work. The single Linear write is the **estimate** field on the items the attention sweep sizes (Owner ruling 2026-09-03, APP-1003); nothing else, and never on a ticket outside the swept set. Runs on the Linear connector. Follows `convention-linear` and `core-operating-model` throughout.

**Ownership.** Owned by **Aide** (`A1-DE`); see `assistant-aide`. Downstream of Atlas — it reads the cycle Atlas (or Aled) has already **committed**, not the whole backlog, so Aide only ever schedules against agreed scope.

## Trigger

Runs after the cycle is committed (the start of the cycle, or on demand when Aled asks what in the current cycle needs him). Read-only.

**Daily review is the daily cadence, not a separate skill (APP-793).** Aled's end-of-day ask — what moved in the committed cycle today, what did not, and what tomorrow's shape should be — is served by running this sweep at end of day and handing to `skill-time-block`'s daily pass (which reads Linear's actual state, checks off what closed against what the day's holds said would happen, and books the next hold-day); it is not a separate `skill-daily-review`. The daily run reads the same population at smaller scope — the day's state changes and Done transitions — so no new skill is needed, only the daily cadence of the existing loop.

## Scope — the committed cycle only

Sweep the **current committed cycle** across the delivery projects on the delivery teams named in `convention-linear`'s team table — **Apps, MBN, A1, Mr Pritchard**; **where this scope and that table disagree, the table 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: APP-521, APP-550). **Never the whole board, never Pipeline.** If no cycle is committed yet, say so and stop — there is nothing agreed to schedule against (the sweep is downstream of Atlas's commit, per `assistant-aide`).

**The estimate write is scoped to the whole Owner lane, not to the cycle.** Everything above bounds what the sweep **schedules**, and that bound stands. The **estimate** write is the one thing that does not sit inside it: it extends to **every ticket routed to `human` and assigned to Aled, wherever it sits** — any delivery team, any project, in a cycle or out of one, Backlog and Refinement included. That is the set `convention-linear`'s rule actually names (*The Owner lane carries an estimate*, Owner ruling 2026-09-03, APP-1003): "Any ticket routed to `human` and assigned to Aled carries Linear's native **estimate**", and "An Owner-lane ticket with no estimate is an Aide defect, never a small item". A writer bounded to the committed cycle can never satisfy that rule — most of the Owner lane is out of cycle by construction, and a run stopped by the freshness test writes nothing at all — so the bound and the rule cannot both hold. Measured 2026-09-10: 200 Owner-lane tickets across Apps, A1, MBN and Mr Pritchard, `estimate` explicitly requested, the field **absent from 200 of 200**, and the listing still paginating. **Where the freshness test stops the run, the estimate pass still runs over the Owner lane and the report says so** — the freshness test guards what may be *booked against*, never what may be *sized*, and a stale cycle makes an unsized Owner ticket no more accurate. Sizing follows *Classify and size* below unchanged: the same 15m/30m/1h/2h scale, the same Exponential mapping, never overwrite an Owner-set value, and >2h is written as 16 and surfaced for Relay. **Surfaced, not routed: the 2026-10-12 routing grant is cycle-bounded and does not follow the estimate write out of the cycle (APP-2679).** The grant below reaches "only a ticket on the swept set that this sweep's own sizing put over 2h", and the swept set is committed-cycle-scoped — so the surface-only wording in this sentence is the out-of-cycle rule, not a line the 2026-10-12 edit failed to reach. It is the boundary this paragraph already draws: an Owner-lane ticket sized but out of cycle is not thereby eligible for the unattended behaviours the cycle scope gates, and setting `agent:R3-LAY` and clearing an assignee is a state change on the Owner's board rather than a sizing. **And where the freshness test stops the run, nothing is routable at all** — there is no swept set, so the grant's own bound is empty by construction; the freshness test guards what may be *booked against* and never what may be *sized*, and a relabel is neither. Widening the grant past the swept set would widen a bound the Owner himself set, so it is his call and not this pass's: until he rules otherwise the out-of-cycle >2h finding is reported in the run's output and left for him to route. Worked case: the weekly run of 2026-10-26 was stopped by the freshness test on all four delivery teams and sized 8 Owner-lane tickets, of which MBN-340 — Blocked, Urgent, `human` + `operator-bara`, assigned Aled, no cycle — was the only one over 2h; it was sized 16 and surfaced, not routed (APP-2679). **Nothing else leaves the cycle.** The classified sized worklist, the bounded auto-hold envelope (APP-828), the operator-scoreboard snapshot and the retrospective read are all committed-cycle-scoped exactly as they are today, and an Owner-lane ticket that is sized but out of cycle is **not** thereby eligible for unattended booking.

**The estimate pass is bounded per run and resumes off the board, not off a stored marker (APP-1307).** The scope above is the whole lane; the progress through it is incremental, and a run that silently narrows the scope and a run that spends its whole budget on a one-time backfill are both defects. So: each run sizes the **committed-cycle** Owner-lane population first — that set is already being read for the sized worklist, so it costs nothing beyond the write — then sizes **up to 25 further Owner-lane tickets that carry no estimate**, taken in **oldest-`updatedAt`-first** order across the delivery teams named above. That order *is* the resumption mechanism, and it is why no cursor, marker or per-team state is kept: a sized ticket leaves the unestimated set by construction, so the next run's oldest-first read begins where this one stopped, and nothing already cleared is re-scanned. Computing the position from board state rather than storing it beside the board is the same discipline as coordinate's `[coordinate]` watermark (APP-1208) — a stored marker goes stale the moment another hand sizes, re-labels or closes a ticket, and is then wrong in the direction that hides work. The cap of 25 keeps a daily run's reads and writes proportionate while clearing a lane of this size within about a week of ordinary runs; it bounds the **batch**, never the **scope**, and it never reduces what the run would already size for the worklist. **Report the pass in two figures** — Owner-lane tickets still unestimated, and how many this run sized — so the backlog is visible as a falling number rather than inferred from silence. Where that number is not falling run on run, raise it as a defect; a run never widens its own cap to compensate. Everything else in *Classify and size* applies unchanged: the same 15m/30m/1h/2h scale and Exponential mapping, never overwrite an Owner-set value, >2h written as 16 and **surfaced for Relay, not routed** — the cycle-bounded reading stated under *The estimate write is scoped to the whole Owner lane, not to the cycle* above, which this sentence is not a second and looser copy of (APP-2679). (Measured 2026-09-11, A1 alone, first 50 Owner-lane tickets: 20 estimated, 30 not, and eighteen of the twenty in the current committed cycle — the committed-cycle-only write of 2026-09-10 is legible on the board as exactly that shape. APP-1307.)

**Test freshness, not just existence (APP-820, APP-987).** A committed cycle is only the right thing to sweep if it has been **approved this boundary**. The approval signal (defined in `task-cycle-planning`) is **the `Committed by Aled — <date>` line in the per-cycle goal document, dated on or after the latest `[cycle-planning]` proposal comment on that document** (Owner decision, Aled 2026-09-21, APP-1567) — not a cycle-membership write, which the delivery loop and the boundary auto-transfer produce without any Owner act (A1-345, 2026-08-17: a Relay membership restore was read as approval and booked against). Read the team's `<team>.cycle-goal.YYYY-Www` document and its latest proposal comment: where the document carries that line, the cycle is approved and current; where it carries no such line, it is still awaiting Aled and the cycle you can see is last boundary's. **A later `updatedAt` is not by itself that write — read the body and require a positive content signal.** A document can be re-touched without being edited, and a bare timestamp comparison reads the re-touch as approval: the run is then booking against a proposal nobody agreed. The signal to require is the `Committed by Aled — <date>` line itself (APP-1567, 2026-09-21). Every connector write authors as *Aled Pritchard*, so neither the author field nor a later `updatedAt` can tell the Owner from the fleet. A body with the *proposed, not committed* markings removed but no line is not approved either. A proposal posted by Friday's 16:00 run is two to three days old by Monday's run; that age is not a staleness sign, and only the missing line is (APP-1577). Where the timestamp says fresh and the body is still the unedited proposal, the cycle is **not** approved; report it as awaiting Aled and book nothing. This narrows APP-987 the way APP-987 narrowed APP-820: each pass removes a signal that moves without the Owner moving it. (Worked case: `a1.cycle-goal.2026-W38`, 2026-09-14 — the document's `updatedAt` of 11:07:54Z sat 4h25m after its own `[cycle-planning]` comment at 06:42:23Z, where Apps and MBN differed by milliseconds, and the body was still verbatim proposal text; caught only by re-reading the content — APP-1466.) In that case report "the committed cycle predates this week's proposal, which is awaiting your approval" and stop — the same posture as "no cycle committed". Never sweep or size a stale cycle. **The test has a second half: the cycle you sweep must cover the day being booked (APP-1047).** The freshness test guards the cycle *behind* the boundary; nothing above guards the one *ahead* of it. `skill-time-block` resolves "tomorrow" as the next day carrying a hold window (APP-872), so a Friday or Saturday end-of-day run whose tomorrow is Monday is booking a day in cycle N+1 while the only sized worklist is cycle N's — every delivery team's cycle ends Sunday 23:00Z, so this is weekly, not an edge. Resolve the **target day's** cycle first (`list_cycles` for the team, compare the day against `startsAt`/`endsAt`); where that cycle is not yet committed — no `<team>.cycle-goal.YYYY-Www` document, or one with no `Committed by Aled — <date>` line dated on or after its latest proposal comment — report "tomorrow falls in cycle N+1, which has no commit yet — nothing booked" and stop, the same posture as stale-cycle and no-cycle. **Never book the next cycle's day from the expired cycle's worklist** (Owner ruling, Aled 2026-09-03, APP-1047): with auto-add off and the marker line the only commit signal, booking from the old list would reintroduce the false-approve this test exists to prevent, arriving from the other direction. The structural fix — committing N+1 before the boundary weekend — is `task-cycle-planning` timing, not a booking rule; a run that stops here says so once in its report rather than silently no-opping (the APP-872 failure). (Worked case: the Saturday 2026-08-22 EOD run, tomorrow = Monday 24 Aug in Apps cycle 7, zero issues and no commit, while cycle 6 ended 23 Aug — APP-1047.)

**Report how long a cycle has sat unapproved, not only that it has.** The test above is run-by-run, so its report reads identically on day one of a boundary and on day seven, and a week-long stall is absorbed into routine daily silence. So where the test stops the run, the report names the **age of the uncommitted proposal** beside the stop: the date of the latest `[cycle-planning]` proposal comment on each team's `<team>.cycle-goal.YYYY-Www` document, the whole days since it, and the number of cycle boundaries it has now crossed — and where every delivery team is in that state, one line saying so rather than four. The figures are computed from the documents the test already reads, never from a stored counter, the same discipline the estimate pass follows in resuming off the board: a counter kept beside the board goes stale the moment a commit lands from another hand. **Past one crossed boundary the stall is its own item, not a daily silence** — report it as needing either the commit or a change to the Friday proposal cadence (`task-cycle-planning`), rather than repeating the ordinary awaiting-Aled line a seventh time. (Worked case: the 2026-10-01 end-of-day run found all four `<team>.cycle-goal.2026-W40` documents marked `⏳ Proposed — not committed`, proposed 2026-09-25 and rewritten wholesale on 2026-09-29 with still no `Committed by Aled` line, so the APP-828 auto-hold envelope was empty by construction across Apps, A1, MBN and Mr Pritchard for a full week — and nothing in any run's report distinguished that from day one — APP-1961.)

## What counts as "needs Aled"

Include a cycle item if any of these holds:

- **Assigned to Aled** — anything on his plate directly, **except a ticket carrying `agent:PUL-5E`**: a Pulse canon-intake note shows an assignee only because the resting-Blocked automation reassigns it to its creator, not because it is Aled's to action in a calendar block — it needs the drain, not hold time. Exclude `PUL-5E`-labelled tickets from this criterion so the sweep does not consume hold time on notes marked "do not author from this note" (APP-686).
- **Human-lane** — carries the `agent`-group value `human` (his decisions, design, launch ops, on-device verifies).
- **Awaiting his review or approval** — In Review carrying `agent:PR-1SM` (or a QA write-up) with him assigned; the merge-gate sign-offs only he gives.
- **An open decision** — a ticket whose latest unprefixed comment poses a question to him, or a Refinement ticket assigned to him carrying a genuine question (per `convention-ticket`).

Exclude pure agent work with no gate for Aled — Forge build legs, Relay routing, Pulse intake — unless one of the above applies.

## Classify and size

For each included item:

1. **Classify the attention it wants** — `decision` (a call to make), `review` (sign-off on built work), `action` (something for him to do), or `deep-work` (a focused build/think block he owns).
2. **Size it, and write the estimate.** Size into one of **15m / 30m / 1h / 2h** — the shared sizing scale Aide books against — from the ticket's shape, not its title alone, and **write it to the ticket's native `estimate` field** on the Exponential scale every team runs: **1** = 15m (a one-word verdict is a 1) · **2** = 30m · **4** = 1h · **8** = 2h. Where an estimate is already present, read it and re-size only where the ticket's shape has plainly changed; never overwrite an Owner-set value. This is the sweep's one Linear write (Owner ruling 2026-09-03, APP-1003): the estimate is native, so the morning brief, `skill-time-block` and `task-cycle-planning`'s capacity note bucket by it instead of re-sizing by hand, and the Owner can triage his own lane by state plus size without opening each ticket — a one-word verdict and fifteen minutes of recall no longer look identical in `In Review` (MRP-41 beside MRP-45, 2026-08-17). **Read the estimate back on every write, and report confirmed writes only.** A `save_issue` estimate write can return 200 with the field unset and `updatedAt` unmoved, and succeed on an identical retry (`convention-linear`, *Writing Linear safely*; APP-1448). So the pass confirms each write from the response and retries once where the field is absent, and the two figures it reports — Owner-lane tickets still unestimated, and how many this run sized — are counts of **confirmed** writes. At 2 in 25 across a lane of ~109 the drift is enough to defeat this skill's own "where that number is not falling run on run, raise it as a defect" check, which is the one thing that would otherwise catch it. **An Owner-lane ticket left without an estimate is an Aide defect, never a small item** — team settings have count-unestimated off so the gap shows as a gap.
3. **Oversized → estimate 16, surface for Relay, don't schedule.** Anything that genuinely needs **more than 2h** is too big for a single hold: write **16** (over two hours) so the size is visible on the ticket, **surface it in the run's report** as needing Relay to split, and **leave it out of the sized list** — do not size or schedule an item that should be decomposed first. Aide is **read-only on Linear apart from the estimate**, so it names the split for Aled to route to Relay; it does **not** write the Relay comment itself (APP-739 / APP-686).

   **And Aide routes the oversized item to Relay herself** (Owner ruling, 2026-10-12 — APP-2279). The clause above was the read-only carve-out as first written, and it made every weekly run surface a hand-off the Owner then had to route by hand; he ruled that she does it herself. So on an item this sweep has sized over 2h: set `agent:R3-LAY`, **clear the assignee in the same write** per the fleet-executor invariant, comment the decomposition brief, and report the routing in the run's output — rather than naming it for him. The grant is a **bounded second exception** to the read-only default, not a loosening: it reaches only a ticket on the swept set that **this sweep's own sizing** put over 2h, and nothing else. Relay still decides how to split and the Owner still owns the resulting Owner-lane legs, so no judgement is added beyond the one already made by sizing. **And test for existing children before naming a split:** an epic is over 2h by construction and will always trip a size-only test, so read the children first and record the decomposition that already exists instead of asking Relay to redo done work. (Worked case: the weekly `task-aide-loop` pass of 2026-10-12 sized two Owner-lane tickets over 2h and surfaced both. On the Owner's instruction in session, APP-2133 was routed — `human` → `R3-LAY`, assignee cleared in the same write, estimate 16 left visible, a four-leg brief commented — and APP-2094 was **not**, because the epic was already decomposed into six spikes, one of them Done. The quoted ruling and the two tickets' outcomes are the filing leg's report and are **unverified** here, no transcript or run log being readable from the refine surface; that flag covers those three only — APP-2279.)

## Reading Linear safely

Per `convention-linear` (*Reading Linear safely*): scope reads **per project**, not per team, and filter by cycle plus state so a bulk `list_issues` doesn't overflow; the `agent`-group filter takes the **bare** value (`human`, `PR-1SM`), not the displayed `agent:` form; a `Backlog` filter also returns Refinement, so re-check each ticket's state name; and read comment **bodies**, not the author field, to tell an operator question from an agent comment.

## Output

Produce the **classified, sized worklist** — one line per item: `ID · title · class (decision/review/action/deep-work) · size (15m/30m/1h/2h) · why it needs Aled`. List oversized-and-routed items separately with a note that they went to Relay to split. This list is the input to `skill-time-plan` (which allocates the week's shape against it) and `skill-time-block` (which books the holds). This skill hands off the list; it does not allocate or book.

**This sized list is the bounded auto-hold envelope (APP-828).** Aide's graduation to unattended booking (`assistant-aide`, `skill-time-block`) is bounded to exactly the items this sweep has placed on the sized worklist — committed-cycle items, sized to 15m/30m/1h/2h, each routed to a lane that has a hold window. Oversized-and-routed items (>2h), and anything the sweep could not size, sit **outside** the envelope and still require Aled's confirmation. The sweep therefore defines the envelope by construction: to be eligible for unattended booking, an item must appear on this list.

## Operator scoreboard snapshot (APP-575)

This sweep already reads the exact human-lane population Aide is measured on (`assistant-aide` *Success measure*), so it emits the weekly **operator-scoreboard snapshot** as a near-zero-cost by-product of the run. Alongside the sized worklist, report:

- **Lane size and latency** — the count of open items in Aled's lane, and the **median time-to-first-touch** (from an item landing on him — assigned, or In Review on `human` — to his first touch), against the 2026-07-17 baseline (63 items, ~15d median).
- **Throughput** — `human`-executor tickets moved to Done since the last snapshot (human-lane completions only, not every ticket Aled closes), read from **Done-state transitions**, never comment authorship (the connector stamps every comment as Aled).
- **Focus / breadth / adherence** — for those completions: how many were in the committed cycle versus pulled ad hoc (focus ratio), how many distinct projects/ventures they span (context breadth), and the share of the cycle's human-lane items done by cycle end (cycle adherence).

A read-and-report by-product only — the sweep writes nothing. `task-daily-report` carries the running counts day to day; this weekly snapshot is the cleaner measurement point.

## Emit the retrospective read (APP-599)

The adaptation layer that `skill-time-plan` owns is fed from outcomes read back across runs, and this sweep already reads the exact population and Done-state history it needs — so it emits the **retrospective read** as a second near-zero-cost by-product, on the same weekly cadence (or one week where the signal is stark). It reports, over the review window: which sized/placed blocks **worked** — judged on **Done-state transitions plus decisions cleared, never Done alone** — which deep-work blocks went untouched, and any block the Owner **moved** (surfaced from `skill-time-block`'s block-identity read-back, APP-898 — the strongest placement-preference signal available). This is a read-and-report by-product only; the sweep proposes nothing and writes nothing. `skill-time-plan` consumes this read to **propose** heuristic adjustments — Aide never silently self-tunes, and the sweep never re-prioritises.

**A third input, written at close-out: scheduled versus actual (APP-1662).** Everything the read carries above is inferred from board state after the fact — Done-state transitions, decisions cleared, an untouched deep-work block, a block the Owner moved. Those say whether a block was *used*; none of them says whether its **size** was right, because no elapsed time and no close-out write exist anywhere in the loop. So the read carries a third input: for each of Aled's booked sessions inside the review window, its **scheduled versus actual duration**, and a **per-ticket outcome of done / partial / deferred**. That input is *written* by the daily close-out step in `assistant-aide`'s Composition, not by this sweep — the sweep reads it and folds it in beside the other two, so sizing calibrates against what a session actually took instead of against the estimate that booked it. Where a booked session has no close-out entry, **report the gap rather than inferring a duration from the calendar**: a block that over-ran or was moved and that nobody logged is exactly the case the first two reads already miss, and a guessed duration would feed the adaptation layer a number it cannot distinguish from a measured one. (Worked case: the BARA sign-off session of 2026-09-22 — an Aide-booked block that ran long, was interrupted by two genuine findings, and ended with two tickets pushed to a later slot, none of which reached any surface — APP-1662.)

**Where this anchors, and what is deliberately not built (refine's how/where call under APP-1099).** This input anchors **here**, in the sweep that already does the retrospective read and already reads the exact population and Done-state history it needs. Two consequences are deliberate, not omissions: **no new weekly log artefact is created** — the `aide.session-log.YYYY-Www` document APP-1662 proposed is not authored, because a second surface would have to be kept fresh, read and drained to carry what one input on an existing read already carries — and **`skill-time-plan` is not edited**, because its adaptation layer already consumes whatever this sweep emits, so a new input reaches it with no edit at all. The close-out step that writes the input is the one genuinely new thing, and it sits in `assistant-aide`'s Composition where the daily pass runs.

## Guardrails

- **Read-only on Linear, one field excepted.** Never changes state, labels, priority, assignment, or cycle membership — it reads what needs Aled, it does not re-prioritise it. Re-prioritisation is Atlas/Relay's, not Aide's. The single Linear write is the **estimate** field on the items the attention sweep sizes (Owner ruling 2026-09-03, APP-1003); nothing else, and never on a ticket outside the swept set.
- **Committed cycle only.** Never sweeps the whole board or Pipeline; if nothing is committed, stops.
- **Never books calendar** — that is `skill-time-block`. This skill only produces the sized list and the read-back snapshots.
- **Oversized items are routed, not sized** — >2h goes to Relay to split.
- Aled is the gate. The sweep informs; it decides nothing.

## Setup

- Deployed as part of the Aide driver task (Linear + Calendar), run after the cycle is committed. Connector: Linear (read-only) for this skill.
- Cadence: per cycle (weekly), or on demand.

Owned by Aide (A1-DE).

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.
