arcane-cli 1.19.0 → 1.20.0

package/README.md

@@ -275,7 +275,7 @@ The shape is the JSON Schema at [`src/assets/schemas/state.schema.json`](src/ass
 
 ### Presence
 
-`spell presence` is an optional, local presence channel: which session is working on what, right now, and whether it is waiting for you ([ARC-060](DECISIONS.md#arc-060--the-presence-channel-one-package-behind-spell-presence-a-loopback-contract-checkout-keyed-sessions-and-a-prompt-driven-reporting-convention); working name `arcane-mcp`). You start the service; nothing listens until you do. It binds `127.0.0.1` only, keeps sessions in memory only (stale after 90 s without a report, dropped after 24 h), writes nothing but its token and `server.json` under `~/.arcane/presence/`, and never writes a repository file. It is observation only: everything it holds is reconstructable from `spell state --json`, and no route, tool or event steers a session. Spells report through it with one fragment in `spell-open-session`, `spell-close-session`, `spell-commit-work` and `spell-implement`, and every spell's "Needs you" block reports `waiting` with its lines; with no service running they behave exactly as before. `spell-open-session` also lists the sessions reporting from the repository's other checkouts, and `spell doctor` has a "Presence service" row (`--fix` removes a `server.json` left by a service that is gone).
+`spell presence` is an optional, local presence channel: which session is working on what, right now, and whether it is waiting for you ([ARC-060](DECISIONS.md#arc-060--the-presence-channel-one-package-behind-spell-presence-a-loopback-contract-checkout-keyed-sessions-and-a-prompt-driven-reporting-convention); working name `arcane-mcp`). You start the service; nothing listens until you do. It binds `127.0.0.1` only, keeps sessions in memory only (stale after 90 s without a report, dropped after 24 h), writes nothing but its token and `server.json` under `~/.arcane/presence/`, and never writes a repository file. It is observation only: everything it holds is reconstructable from `spell state --json`, and no route, tool or event steers a session. Spells report through it with one fragment in `spell-open-session`, `spell-close-session`, `spell-commit-work` and `spell-implement`, and every spell's "Action required" block reports `waiting` with its open **Now** lines; with no service running they behave exactly as before. `spell-open-session` also lists the sessions reporting from the repository's other checkouts, and `spell doctor` has a "Presence service" row (`--fix` removes a `server.json` left by a service that is gone).
 
 | Command | What it does |
 | --- | --- |
@@ -283,7 +283,7 @@ The shape is the JSON Schema at [`src/assets/schemas/state.schema.json`](src/ass
 | `spell presence status` | Exit 0 when the service answers this machine's token, 1 otherwise |
 | `spell presence sessions [--json]` | The sessions the service holds, as a table or as the `GET /v0/sessions` document; exit 1 when no channel answers |
 | `spell presence stop` | Stops the recorded service; exit 0 either way |
-| `spell presence report --status <s> [--task ...] [--needs-you ...]` | Reports this checkout's session; silent and exit 0 with no service, never blocks |
+| `spell presence report --status <s> [--task ...] [--required-action ...]` | Reports this checkout's session; silent and exit 0 with no service, never blocks |
 | `spell presence end` | Ends this checkout's session |
 | `spell presence mcp` | The same channel as an MCP server over stdio: tools `presence_report` and `presence_end`, resources `arcane://presence/sessions` and `arcane://presence/capabilities`, with update notifications on the sessions resource (`subscriptions/listen` on MCP 2026-07-28, `resources/subscribe` on earlier revisions) |
 

package/dist/assets/.arcane/governance/spell-authoring-standards.md

@@ -231,40 +231,52 @@ Arcane's own repository, a test (`test/up02-d-runtime-placeholders.test.ts`) fai
 `status: active` governance document uses a token that is not in this list. Whether an agent actually
 resolves a listed token from the named source is explicitly advisory prose: no check exercises it.**
 
-## Required operator actions: the `Needs you` block
+## Required operator actions: the `Action required` block
 
 Some runs end with an action only the operator can take: approving or merging a pull request,
 accepting a decision record, answering a question the work is waiting on, confirming a `guarded`
 push, running an interactive command such as `spell unblock-push`, or a step on an external platform
 the agent cannot reach. Listed among optional next steps, such an action gets skimmed past. A spell
-whose output can carry one reports it in one fixed block instead:
-
-- **One fixed heading,** `## ⚠ Needs you`, at the very top of the final report, before every other
-  section and before any optional next step.
-- **One line per action:** exactly what to do, then why the agent cannot do it itself.
+whose output can carry one reports it in one fixed block instead. The block hands over authority:
+these are the operator's decisions, so it never reads as the agent asking for help.
+
+- **One fixed heading,** `## 🚧 Action required`, at the very top of the final report, before every
+  other section and before any optional next step, framed by a horizontal rule above and below so it
+  stands apart in a terminal as well as on a rendered page.
+- **Two tiers in one block:** **Now** for what the work is not correct or complete without, and
+  **When you're at your desk** for what only the operator can do but that can wait. An empty tier is
+  left out; the tiers are never split into two blocks.
+- **One line per action:** exactly what to do, then why only the operator can do it.
 - **Never only among optional steps:** an action required for correctness may be repeated under next
   steps or suggestions, but it always appears in the block.
-- **Omitted when empty:** when nothing needs the operator, the block is left out entirely, never
-  printed as an empty heading or a "None" line.
+- **Done items stay, struck through:** within a session, a listed item stays in every later report of
+  the block, struck through once done, so progress shows and nothing disappears silently.
+- **Omitted when empty:** when nothing is left for the operator and nothing was struck through, the
+  block is left out entirely, never printed as an empty heading or a "None" line.
 
-The block's wording lives in one shared prose fragment (ARC-039), `needs-you`, kept in Arcane's
+The block's wording lives in one shared prose fragment (ARC-039), `action-required`, kept in Arcane's
 source under `.arcane/spells/_fragments/` and never shipped on its own. A spell carries it as a
-`<!-- fragment:needs-you:start -->` / `<!-- fragment:needs-you:end -->` marker pair placed where the
-spell describes its final output or report, and `npm run fix:self-host-parity` expands the fragment
-between the markers. Edit the fragment, never an expanded copy, and never restate its rules by hand
-in a spell body. Any shipped Markdown file can host a fragment the same way, not only a spell: the
-`branch-naming` fragment is expanded into `git-conventions.md` and the Copilot instruction file as
-well as into spells, and `spell agents sync` renders it into every client instruction file, so the
-branch formats are written in exactly one place. Required actions also survive the end of a session: `spell-close-session` writes
-the open items into the handoff's `Needs you` field, and `spell-open-session` surfaces that field
-first, above the rest of the handoff, and does not mark the handoff consumed until it has.
+`<!-- fragment:action-required:start -->` / `<!-- fragment:action-required:end -->` marker pair placed
+where the spell describes its final output or report, and `npm run fix:self-host-parity` expands the
+fragment between the markers. Edit the fragment, never an expanded copy, and never restate its rules
+by hand in a spell body. Any shipped Markdown file can host a fragment the same way, not only a
+spell: the `branch-naming` fragment is expanded into `git-conventions.md` and the Copilot instruction
+file as well as into spells, and `spell agents sync` renders it into every client instruction file,
+so the branch formats are written in exactly one place. Required actions also survive the end of a
+session: `spell-close-session` writes the open items into the handoff's `Action required` field, in
+its `Now` and `At your desk` lines, and `spell-open-session` surfaces that field first, above the
+rest of the handoff, and does not mark the handoff consumed until it has. A handoff written before
+the rename carries a `Needs you` field instead; open-session reads its items as **Now** items.
+
+When a presence channel is configured, the **Now** tier is also reported as `waiting`, one
+`--required-action` line per open item; the other tier is never sent.
 
 **Enforcement: executable check (ARC-023) for the wording — in Arcane's own repository,
 `npm run check:self-host-parity` fails CI when a spell's expanded span differs from the fragment, and
-a test (`test/up04-b-needs-you.test.ts`) fails when the fragment loses its heading, placement or
-omit-when-empty rule, or when a spell in the chosen set loses its span. Which spells carry the span
-is decided by an author's judgment, and whether an agent actually emits the block is explicitly
-advisory prose: no check reads a spell's output.**
+a test (`test/action-required.test.ts`) fails when the fragment loses its heading, frame, tiers,
+placement or omit-when-empty rule, or when a spell in the chosen set loses its span. Which spells
+carry the span is decided by an author's judgment, and whether an agent actually emits the block is
+explicitly advisory prose: no check reads a spell's output.**
 
 ## How to audit a spell
 

package/dist/assets/.arcane/governance/threat-model.md

@@ -76,11 +76,11 @@ See also: [Hardening Checklist](hardening-checklist.md), [Authentication Strateg
 
 > **Status:** every row is **Planned** until the operator verifies it against the installed build on each machine that runs the service, and records the result in the security audit log. Decision record: ARC-060 (the presence channel) in the Arcane framework repository.
 
-`spell presence serve` is an optional, operator-started foreground process that AI sessions report to (agent, task, repository, status and "needs you" lines) and that dashboards read. Nothing listens until the operator starts it. It adds one listening socket and one secret to the machine. It is **observation only by contract** (capability descriptor `{ observe: true, actions: [] }`) and **never authoritative**: everything it holds is reconstructable from `spell state --json` and the repository's files.
+`spell presence serve` is an optional, operator-started foreground process that AI sessions report to (agent, task, repository, status and "action required" lines) and that dashboards read. Nothing listens until the operator starts it. It adds one listening socket and one secret to the machine. It is **observation only by contract** (capability descriptor `{ observe: true, actions: [] }`) and **never authoritative**: everything it holds is reconstructable from `spell state --json` and the repository's files.
 
 | Asset | Value | Location |
 |-------|-------|----------|
-| Presence state | Each session's agent, task, message, needs-you lines, repository name and remote, branch and checkout path. Business-private: it can name ventures, customers and machine paths | Process memory only; gone on restart, dropped after 24 h of silence |
+| Presence state | Each session's agent, task, message, required-action lines, repository name and remote, branch and checkout path. Business-private: it can name ventures, customers and machine paths | Process memory only; gone on restart, dropped after 24 h of silence |
 | Presence token | Bearer capability for every route: read every live session, post or end any session | `~/.arcane/presence/token` (file `0600` in a `0700` directory; on Windows restricted to the current account) or the `ARCANE_PRESENCE_TOKEN` environment variable for a subscriber |
 | `server.json` | URL, process id, port, start time and version of the running service. Not a secret | `~/.arcane/presence/server.json`, removed on a clean exit |
 
@@ -101,9 +101,9 @@ See also: [Hardening Checklist](hardening-checklist.md), [Authentication Strateg
 | State persistence | **Planned** | Memory only; a session silent for 90 s is stale, for 24 h expired and dropped; a restart starts empty (decision 7) | Restart `serve`: `GET /v0/sessions` answers an empty list; a session silent for 90 s shows `stale: true` |
 | Forged or poisoned presence | **Accepted risk** | Any token holder can post or end any session. Bounded: presence is never authoritative and steers nothing (`actions: []`, decision 8); a forged report misleads a dashboard and changes no file, branch or decision | `tools/list` on `spell presence mcp` answers only `presence_report` and `presence_end`; the HTTP surface has six routes, none of which acts |
 | Disclosure to token holders | **Accepted risk** | Every token holder can read every session's task, message and path. A process of the operator's account can already read those repositories, so this adds no new data to that account; it is why the token is never shared beyond it | Review which agent runtimes run under the operator's account and what they may read |
-| Request limits | **Planned** | 64 KiB bodies, 256-character lines, at most 20 needs-you lines and 32 aliases (more is refused), 256 sessions, 32 subscribers, a subscriber that stops reading closed past a 1 MiB backlog, connection and header time limits checked every second (decision 3) | A 65 KiB body and a 21-line needs-you list are each refused; the service keeps answering |
+| Request limits | **Planned** | 64 KiB bodies, 256-character lines, at most 20 required-action lines and 32 aliases (more is refused), 256 sessions, 32 subscribers, a subscriber that stops reading closed past a 1 MiB backlog, connection and header time limits checked every second (decision 3) | A 65 KiB body and a 21-line required-action list are each refused; the service keeps answering |
 | Execution and reads | **Planned** | The service runs no process and reads nothing but its own store; it makes no outbound request (decisions 9, 10) | Code review of the release; no outbound connection from the `serve` process during a run (`lsof -p <pid> -i` shows the listener only) |
-| Logging | **Planned** | The service logs an event name, a session reference and a status only; never a task, message, needs-you line, path or token (decision 9) | `serve`'s output across a run contains no task, message, path or token |
+| Logging | **Planned** | The service logs an event name, a session reference and a status only; never a task, message, required-action line, path or token (decision 9) | `serve`'s output across a run contains no task, message, path or token |
 | Remote access | **Planned** | Nothing listens beyond loopback; the only remote path is a tunnel or VPN the operator places in front of the loopback port, with the token still required (decision 6) | Before exposing the port through a tunnel, review which devices the tunnel admits and record them |
 | Git hooks | **Planned** | The reporter is invoked by spell prompts, never by a git hook; `spell presence` is never installed into `.husky/` or `.arcane/hooks/` (decision 10) | A search for `presence` in `.husky/` and `.arcane/hooks/` of each repository after the update that ships it finds nothing |
 | Data leaving the machine | **Planned** | No outbound request; a pushed projection would be a later decision record and strips `repository.root` and `checkout.path` first (decision 9) | Same as the execution row |

package/dist/assets/.arcane/spells/_fragments/action-required.md

@@ -0,0 +1,27 @@
+**Action required — what only the operator can do.** When this run leaves an action that only the operator can take, report it in one block at the very top of the final report, before every other section and before any optional next step. The block exists because these are the operator's decisions to make, not because the agent is stuck: write it as a hand-off of authority, never as a plea for help. Frame it with a horizontal rule above and below, so it stands apart in a terminal as well as on a rendered page:
+
+```markdown
+---
+
+## 🚧 Action required
+
+**Now**
+
+- <exactly what to do: the command, the link, or the question> — <why only the operator can do it>
+
+**When you're at your desk**
+
+- <exactly what to do> — <why only the operator can do it>
+
+---
+```
+
+- **What belongs in it:** an action only the operator can take — approving or merging a pull request, accepting a decision record, answering a question the work is waiting on, confirming a `guarded` push, running an interactive command such as `spell unblock-push`, or a step on an external platform the agent cannot reach. An optional suggestion, a next spell to run, or anything the agent could do itself is not a required action and stays out of the block.
+- **Two tiers, one block.** **Now** holds what the work is not correct or complete without. **When you're at your desk** holds what only the operator can do but that can wait: a permission rule, a leftover remote branch, a credential to set up. Leave out a tier that has nothing in it; never split the tiers into two blocks.
+- **One line per action.** Say exactly what to do, then, after the dash, why only the operator can do it. Write the command, link or question out in full; never point elsewhere with "see above".
+- **Never only among optional steps.** An action required for correctness is never listed only under next steps, suggestions, `Carry Forward` or `What's Next?`. It may be repeated there, but it always appears in this block.
+- **Done items stay, struck through.** Within one session, once an item has been listed, keep it in every later report of the block; when the operator has done it, strike it through (`~~<the line>~~`) rather than dropping it, so progress shows and nothing disappears silently. The session's close carries only the open items forward.
+- **Omit it when empty.** When nothing is left for the operator and nothing was struck through this session, leave the block out entirely: no heading, no rules and no "None" line.
+- **Every final report.** The block belongs in whatever report ends the run, including a report written when the spell stops early.
+- **Report the Now tier to the presence channel.** When the **Now** tier has open items, also run `spell presence report --status waiting --required-action "<line 1>" --required-action "<line 2>"`, one flag per open line of that tier; the other tier is not blocking and is not reported. With no presence channel configured on this machine the command prints nothing and exits 0, so the block itself and the rest of the run are unchanged.
+- Enforcement: explicitly advisory prose (ARC-023) — no check reads a spell's actual output for this block; it holds by these instructions alone.

package/dist/assets/.arcane/spells/_fragments/presence-report.md

@@ -5,7 +5,7 @@ in the user store opens it. Report with the CLI only; never pass a token on the
 never write a repository file to report.
 
 - At the start of this spell: `spell presence report --spell <spell-id> --status working --task "<the task in one line>"`.
-- When this spell's output carries a `## ⚠ Needs you` block: `spell presence report --status waiting --needs-you "<line 1>" --needs-you "<line 2>"`, one flag per line; the block itself is unchanged.
+- When this spell's output carries a `## 🚧 Action required` block with open **Now** items: `spell presence report --status waiting --required-action "<line 1>" --required-action "<line 2>"`, one flag per open Now line; the block itself is unchanged.
 - At a checkpoint worth showing (a commit made, a story passed): `spell presence report --status working --task "<what is now happening>"`.
 - When the session closes: `spell presence end`.
 

package/dist/assets/.arcane/spells/spell-address-review.md

@@ -116,23 +116,35 @@ Resolve threads via the provider:
 3. `git push` all commits.
 4. Print a summary table of actions taken (category, file, action, commit), thread status (resolved / deferred-with-TODO / needs manual resolution), commits pushed, and next steps (CI, notify reviewer, ready for re-review).
 
-   <!-- fragment:needs-you:start -->
-   **Needs you — required operator actions.** When this run leaves an action that only the operator can take, and the work is not correct or complete until it is taken, report it in one block at the very top of the final report, before every other section and before any optional next step:
+   <!-- fragment:action-required:start -->
+   **Action required — what only the operator can do.** When this run leaves an action that only the operator can take, report it in one block at the very top of the final report, before every other section and before any optional next step. The block exists because these are the operator's decisions to make, not because the agent is stuck: write it as a hand-off of authority, never as a plea for help. Frame it with a horizontal rule above and below, so it stands apart in a terminal as well as on a rendered page:
 
    ```markdown
-   ## ⚠ Needs you
+   ---
 
-   - <exactly what to do: the command, the link, or the question> — <why the agent cannot do it itself>
+   ## 🚧 Action required
+
+   **Now**
+
+   - <exactly what to do: the command, the link, or the question> — <why only the operator can do it>
+
+   **When you're at your desk**
+
+   - <exactly what to do> — <why only the operator can do it>
+
+   ---
    ```
 
-   - **What belongs in it:** an action the work needs that only the operator can take — approving or merging a pull request, accepting a decision record, answering a question the work is waiting on, confirming a `guarded` push, running an interactive command such as `spell unblock-push`, or a step on an external platform the agent cannot reach. An optional suggestion, a next spell to run, or anything the agent could do itself is not a required action and stays out of the block.
-   - **One line per action.** Say exactly what to do, then, after the dash, why the agent cannot do it. Write the command, link or question out in full; never point elsewhere with "see above".
+   - **What belongs in it:** an action only the operator can take — approving or merging a pull request, accepting a decision record, answering a question the work is waiting on, confirming a `guarded` push, running an interactive command such as `spell unblock-push`, or a step on an external platform the agent cannot reach. An optional suggestion, a next spell to run, or anything the agent could do itself is not a required action and stays out of the block.
+   - **Two tiers, one block.** **Now** holds what the work is not correct or complete without. **When you're at your desk** holds what only the operator can do but that can wait: a permission rule, a leftover remote branch, a credential to set up. Leave out a tier that has nothing in it; never split the tiers into two blocks.
+   - **One line per action.** Say exactly what to do, then, after the dash, why only the operator can do it. Write the command, link or question out in full; never point elsewhere with "see above".
    - **Never only among optional steps.** An action required for correctness is never listed only under next steps, suggestions, `Carry Forward` or `What's Next?`. It may be repeated there, but it always appears in this block.
-   - **Omit it when empty.** When nothing needs the operator, leave the block out entirely: no heading and no "None" line.
+   - **Done items stay, struck through.** Within one session, once an item has been listed, keep it in every later report of the block; when the operator has done it, strike it through (`~~<the line>~~`) rather than dropping it, so progress shows and nothing disappears silently. The session's close carries only the open items forward.
+   - **Omit it when empty.** When nothing is left for the operator and nothing was struck through this session, leave the block out entirely: no heading, no rules and no "None" line.
    - **Every final report.** The block belongs in whatever report ends the run, including a report written when the spell stops early.
-   - **Report it to the presence channel.** When the block is not empty, also run `spell presence report --status waiting --needs-you "<line 1>" --needs-you "<line 2>"`, one flag per line of the block; with no presence channel configured on this machine the command prints nothing and exits 0, so the block itself and the rest of the run are unchanged.
+   - **Report the Now tier to the presence channel.** When the **Now** tier has open items, also run `spell presence report --status waiting --required-action "<line 1>" --required-action "<line 2>"`, one flag per open line of that tier; the other tier is not blocking and is not reported. With no presence channel configured on this machine the command prints nothing and exits 0, so the block itself and the rest of the run are unchanged.
    - Enforcement: explicitly advisory prose (ARC-023) — no check reads a spell's actual output for this block; it holds by these instructions alone.
-   <!-- fragment:needs-you:end -->
+   <!-- fragment:action-required:end -->
 
 5. Optionally post the summary back to the PR as a top-level comment for a durable record.
 

package/dist/assets/.arcane/spells/spell-adopt-docs.md

@@ -135,23 +135,35 @@ Hard rules for this phase:
 
 ## Phase 4 — Report
 
-<!-- fragment:needs-you:start -->
-**Needs you — required operator actions.** When this run leaves an action that only the operator can take, and the work is not correct or complete until it is taken, report it in one block at the very top of the final report, before every other section and before any optional next step:
+<!-- fragment:action-required:start -->
+**Action required — what only the operator can do.** When this run leaves an action that only the operator can take, report it in one block at the very top of the final report, before every other section and before any optional next step. The block exists because these are the operator's decisions to make, not because the agent is stuck: write it as a hand-off of authority, never as a plea for help. Frame it with a horizontal rule above and below, so it stands apart in a terminal as well as on a rendered page:
 
 ```markdown
-## ⚠ Needs you
+---
+
+## 🚧 Action required
+
+**Now**
+
+- <exactly what to do: the command, the link, or the question> — <why only the operator can do it>
 
-- <exactly what to do: the command, the link, or the question> — <why the agent cannot do it itself>
+**When you're at your desk**
+
+- <exactly what to do> — <why only the operator can do it>
+
+---
 ```
 
-- **What belongs in it:** an action the work needs that only the operator can take — approving or merging a pull request, accepting a decision record, answering a question the work is waiting on, confirming a `guarded` push, running an interactive command such as `spell unblock-push`, or a step on an external platform the agent cannot reach. An optional suggestion, a next spell to run, or anything the agent could do itself is not a required action and stays out of the block.
-- **One line per action.** Say exactly what to do, then, after the dash, why the agent cannot do it. Write the command, link or question out in full; never point elsewhere with "see above".
+- **What belongs in it:** an action only the operator can take — approving or merging a pull request, accepting a decision record, answering a question the work is waiting on, confirming a `guarded` push, running an interactive command such as `spell unblock-push`, or a step on an external platform the agent cannot reach. An optional suggestion, a next spell to run, or anything the agent could do itself is not a required action and stays out of the block.
+- **Two tiers, one block.** **Now** holds what the work is not correct or complete without. **When you're at your desk** holds what only the operator can do but that can wait: a permission rule, a leftover remote branch, a credential to set up. Leave out a tier that has nothing in it; never split the tiers into two blocks.
+- **One line per action.** Say exactly what to do, then, after the dash, why only the operator can do it. Write the command, link or question out in full; never point elsewhere with "see above".
 - **Never only among optional steps.** An action required for correctness is never listed only under next steps, suggestions, `Carry Forward` or `What's Next?`. It may be repeated there, but it always appears in this block.
-- **Omit it when empty.** When nothing needs the operator, leave the block out entirely: no heading and no "None" line.
+- **Done items stay, struck through.** Within one session, once an item has been listed, keep it in every later report of the block; when the operator has done it, strike it through (`~~<the line>~~`) rather than dropping it, so progress shows and nothing disappears silently. The session's close carries only the open items forward.
+- **Omit it when empty.** When nothing is left for the operator and nothing was struck through this session, leave the block out entirely: no heading, no rules and no "None" line.
 - **Every final report.** The block belongs in whatever report ends the run, including a report written when the spell stops early.
-- **Report it to the presence channel.** When the block is not empty, also run `spell presence report --status waiting --needs-you "<line 1>" --needs-you "<line 2>"`, one flag per line of the block; with no presence channel configured on this machine the command prints nothing and exits 0, so the block itself and the rest of the run are unchanged.
+- **Report the Now tier to the presence channel.** When the **Now** tier has open items, also run `spell presence report --status waiting --required-action "<line 1>" --required-action "<line 2>"`, one flag per open line of that tier; the other tier is not blocking and is not reported. With no presence channel configured on this machine the command prints nothing and exits 0, so the block itself and the rest of the run are unchanged.
 - Enforcement: explicitly advisory prose (ARC-023) — no check reads a spell's actual output for this block; it holds by these instructions alone.
-<!-- fragment:needs-you:end -->
+<!-- fragment:action-required:end -->
 
 Output:
 

package/dist/assets/.arcane/spells/spell-app-store-accounts.md

@@ -366,7 +366,7 @@ The spell produces one **enrollment tracker**, kept in the venture's private ope
 - [ ] Verification tasks: contact details / identity / organization / website / phone / payment method / device
 - [ ] Hardened (Step 6)
 
-### Needs you
+### Action required
 - <the one operator action currently blocking either track>
 ```
 
@@ -387,23 +387,35 @@ The spell did its job when:
 End every run with a short report. The steps only the operator can take — filling in the D&B
 questionnaire, uploading documents, paying a fee, phoning Apple — are required operator actions:
 
-<!-- fragment:needs-you:start -->
-**Needs you — required operator actions.** When this run leaves an action that only the operator can take, and the work is not correct or complete until it is taken, report it in one block at the very top of the final report, before every other section and before any optional next step:
+<!-- fragment:action-required:start -->
+**Action required — what only the operator can do.** When this run leaves an action that only the operator can take, report it in one block at the very top of the final report, before every other section and before any optional next step. The block exists because these are the operator's decisions to make, not because the agent is stuck: write it as a hand-off of authority, never as a plea for help. Frame it with a horizontal rule above and below, so it stands apart in a terminal as well as on a rendered page:
 
 ```markdown
-## ⚠ Needs you
+---
+
+## 🚧 Action required
+
+**Now**
+
+- <exactly what to do: the command, the link, or the question> — <why only the operator can do it>
 
-- <exactly what to do: the command, the link, or the question> — <why the agent cannot do it itself>
+**When you're at your desk**
+
+- <exactly what to do> — <why only the operator can do it>
+
+---
 ```
 
-- **What belongs in it:** an action the work needs that only the operator can take — approving or merging a pull request, accepting a decision record, answering a question the work is waiting on, confirming a `guarded` push, running an interactive command such as `spell unblock-push`, or a step on an external platform the agent cannot reach. An optional suggestion, a next spell to run, or anything the agent could do itself is not a required action and stays out of the block.
-- **One line per action.** Say exactly what to do, then, after the dash, why the agent cannot do it. Write the command, link or question out in full; never point elsewhere with "see above".
+- **What belongs in it:** an action only the operator can take — approving or merging a pull request, accepting a decision record, answering a question the work is waiting on, confirming a `guarded` push, running an interactive command such as `spell unblock-push`, or a step on an external platform the agent cannot reach. An optional suggestion, a next spell to run, or anything the agent could do itself is not a required action and stays out of the block.
+- **Two tiers, one block.** **Now** holds what the work is not correct or complete without. **When you're at your desk** holds what only the operator can do but that can wait: a permission rule, a leftover remote branch, a credential to set up. Leave out a tier that has nothing in it; never split the tiers into two blocks.
+- **One line per action.** Say exactly what to do, then, after the dash, why only the operator can do it. Write the command, link or question out in full; never point elsewhere with "see above".
 - **Never only among optional steps.** An action required for correctness is never listed only under next steps, suggestions, `Carry Forward` or `What's Next?`. It may be repeated there, but it always appears in this block.
-- **Omit it when empty.** When nothing needs the operator, leave the block out entirely: no heading and no "None" line.
+- **Done items stay, struck through.** Within one session, once an item has been listed, keep it in every later report of the block; when the operator has done it, strike it through (`~~<the line>~~`) rather than dropping it, so progress shows and nothing disappears silently. The session's close carries only the open items forward.
+- **Omit it when empty.** When nothing is left for the operator and nothing was struck through this session, leave the block out entirely: no heading, no rules and no "None" line.
 - **Every final report.** The block belongs in whatever report ends the run, including a report written when the spell stops early.
-- **Report it to the presence channel.** When the block is not empty, also run `spell presence report --status waiting --needs-you "<line 1>" --needs-you "<line 2>"`, one flag per line of the block; with no presence channel configured on this machine the command prints nothing and exits 0, so the block itself and the rest of the run are unchanged.
+- **Report the Now tier to the presence channel.** When the **Now** tier has open items, also run `spell presence report --status waiting --required-action "<line 1>" --required-action "<line 2>"`, one flag per open line of that tier; the other tier is not blocking and is not reported. With no presence channel configured on this machine the command prints nothing and exits 0, so the block itself and the rest of the run are unchanged.
 - Enforcement: explicitly advisory prose (ARC-023) — no check reads a spell's actual output for this block; it holds by these instructions alone.
-<!-- fragment:needs-you:end -->
+<!-- fragment:action-required:end -->
 
 ---
 

package/dist/assets/.arcane/spells/spell-architect.md

@@ -111,23 +111,35 @@ Workflow:
 
 8. **Present for review** — show the architecture and story breakdown to the user.
 
-   <!-- fragment:needs-you:start -->
-   **Needs you — required operator actions.** When this run leaves an action that only the operator can take, and the work is not correct or complete until it is taken, report it in one block at the very top of the final report, before every other section and before any optional next step:
+   <!-- fragment:action-required:start -->
+   **Action required — what only the operator can do.** When this run leaves an action that only the operator can take, report it in one block at the very top of the final report, before every other section and before any optional next step. The block exists because these are the operator's decisions to make, not because the agent is stuck: write it as a hand-off of authority, never as a plea for help. Frame it with a horizontal rule above and below, so it stands apart in a terminal as well as on a rendered page:
 
    ```markdown
-   ## ⚠ Needs you
+   ---
 
-   - <exactly what to do: the command, the link, or the question> — <why the agent cannot do it itself>
+   ## 🚧 Action required
+
+   **Now**
+
+   - <exactly what to do: the command, the link, or the question> — <why only the operator can do it>
+
+   **When you're at your desk**
+
+   - <exactly what to do> — <why only the operator can do it>
+
+   ---
    ```
 
-   - **What belongs in it:** an action the work needs that only the operator can take — approving or merging a pull request, accepting a decision record, answering a question the work is waiting on, confirming a `guarded` push, running an interactive command such as `spell unblock-push`, or a step on an external platform the agent cannot reach. An optional suggestion, a next spell to run, or anything the agent could do itself is not a required action and stays out of the block.
-   - **One line per action.** Say exactly what to do, then, after the dash, why the agent cannot do it. Write the command, link or question out in full; never point elsewhere with "see above".
+   - **What belongs in it:** an action only the operator can take — approving or merging a pull request, accepting a decision record, answering a question the work is waiting on, confirming a `guarded` push, running an interactive command such as `spell unblock-push`, or a step on an external platform the agent cannot reach. An optional suggestion, a next spell to run, or anything the agent could do itself is not a required action and stays out of the block.
+   - **Two tiers, one block.** **Now** holds what the work is not correct or complete without. **When you're at your desk** holds what only the operator can do but that can wait: a permission rule, a leftover remote branch, a credential to set up. Leave out a tier that has nothing in it; never split the tiers into two blocks.
+   - **One line per action.** Say exactly what to do, then, after the dash, why only the operator can do it. Write the command, link or question out in full; never point elsewhere with "see above".
    - **Never only among optional steps.** An action required for correctness is never listed only under next steps, suggestions, `Carry Forward` or `What's Next?`. It may be repeated there, but it always appears in this block.
-   - **Omit it when empty.** When nothing needs the operator, leave the block out entirely: no heading and no "None" line.
+   - **Done items stay, struck through.** Within one session, once an item has been listed, keep it in every later report of the block; when the operator has done it, strike it through (`~~<the line>~~`) rather than dropping it, so progress shows and nothing disappears silently. The session's close carries only the open items forward.
+   - **Omit it when empty.** When nothing is left for the operator and nothing was struck through this session, leave the block out entirely: no heading, no rules and no "None" line.
    - **Every final report.** The block belongs in whatever report ends the run, including a report written when the spell stops early.
-   - **Report it to the presence channel.** When the block is not empty, also run `spell presence report --status waiting --needs-you "<line 1>" --needs-you "<line 2>"`, one flag per line of the block; with no presence channel configured on this machine the command prints nothing and exits 0, so the block itself and the rest of the run are unchanged.
+   - **Report the Now tier to the presence channel.** When the **Now** tier has open items, also run `spell presence report --status waiting --required-action "<line 1>" --required-action "<line 2>"`, one flag per open line of that tier; the other tier is not blocking and is not reported. With no presence channel configured on this machine the command prints nothing and exits 0, so the block itself and the rest of the run are unchanged.
    - Enforcement: explicitly advisory prose (ARC-023) — no check reads a spell's actual output for this block; it holds by these instructions alone.
-   <!-- fragment:needs-you:end -->
+   <!-- fragment:action-required:end -->
 
 Rules:
 - Stories must be right-sized per the methodology doc (not "build the entire dashboard").

package/dist/assets/.arcane/spells/spell-close-session.md

@@ -34,7 +34,7 @@ in the user store opens it. Report with the CLI only; never pass a token on the
 never write a repository file to report.
 
 - At the start of this spell: `spell presence report --spell <spell-id> --status working --task "<the task in one line>"`.
-- When this spell's output carries a `## ⚠ Needs you` block: `spell presence report --status waiting --needs-you "<line 1>" --needs-you "<line 2>"`, one flag per line; the block itself is unchanged.
+- When this spell's output carries a `## 🚧 Action required` block with open **Now** items: `spell presence report --status waiting --required-action "<line 1>" --required-action "<line 2>"`, one flag per open Now line; the block itself is unchanged.
 - At a checkpoint worth showing (a commit made, a story passed): `spell presence report --status working --task "<what is now happening>"`.
 - When the session closes: `spell presence end`.
 
@@ -140,7 +140,7 @@ In `ai-context/system-prompt-context.md`, replace the existing `## Next Session
 - **Branch:** Output of `git branch --show-current`.
 - **Blockers:** Known unresolved blockers or dependencies. Write "None" if clear. Write any claim about the local environment (a failing hook, a broken tool, a flaky test) with the date it was observed and a one-line, read-only command that re-verifies it (no install, network fetch, write or secret access): `<claim> — observed YYYY-MM-DD — re-verify: <command>`. An undated environment claim reads as a standing fact, and the next session repeats it after it stops being true.
 - **Pending Verification:** One line per non-`succeeded` item from step 1b: `<what> — <state> — <verification action>`. States: `dispatched`, `pending`, `failed`, `unverifiable` (never list a `succeeded` item here — it belongs in `Last completed step` / TODO.md / the journal instead, worded per the gating above). The verification action is required for `dispatched`, `pending`, and `unverifiable` — "N/A" is only valid for `failed`, where the state is already resolved and there is nothing left to check. Write "None" only if step 1b found every dispatched item resolved to `succeeded` or `failed` before this handoff was written.
-- **Needs you:** One line per action only the operator can take that this session leaves open: `<what to do> — <why the agent cannot do it>`. This block is committed before steps 9–10 run, so write it with them in view and name now the actions they will leave open: the pull request step 9c opens needs a human merge, and when `push_policy` (read it now, per step 9c's push-policy check) is `blocked`, or `guarded` in an autonomous run, the push itself waits on the operator. The closure report's `## ⚠ Needs you` block (step 11) lists the same items, plus any that arose after this handoff was committed. Write "None" when nothing needs the operator. Never leave such an action only in `Blockers`, `Notes` or `Carry Forward`; it may be repeated there, but it always appears here.
+- **Action required:** The open items of this session's `## 🚧 Action required` block, on two sub-lines: `Now: <what to do> — <why only the operator can do it>` for what the work is not correct or complete without, and `At your desk: <what to do> — <why only the operator can do it>` for what can wait; separate several items in one tier with `; `, and leave out a tier that has none. Struck-through (done) items are not carried. This block is committed before steps 9–10 run, so write it with them in view and name now the actions they will leave open: the pull request step 9c opens needs a human merge, and when `push_policy` (read it now, per step 9c's push-policy check) is `blocked`, or `guarded` in an autonomous run, the push itself waits on the operator. The closure report's `## 🚧 Action required` block (step 11) lists the same items, plus any that arose after this handoff was committed. Write "None" when nothing is left for the operator. Never leave such an action only in `Blockers`, `Notes` or `Carry Forward`; it may be repeated there, but it always appears here.
 - **Notes:** Anything time-sensitive, fragile, or contextual that would be lost if not stated explicitly. Never the sole carrier of durable content (session handoff durability) — if it names unfinished work, that work must also be registered per step 4b; name its location here. An environment claim here follows the `Blockers` rule: date it and give its re-verify command.
 ```
 
@@ -196,7 +196,7 @@ Rules:
    - Timeout, cancellation, fallback, or delegated response is not approval. Print the visible authorization downgrade and halt without committing.
 
    c. **Push and open a PR through `spell-commit-work` step 9, including its separate merge gate:**
-   - Run the push-policy check before the push. `spell-commit-work` step 9a runs the same check; run it once per push, not twice. It also governs step 10's remote branch deletions. If it stops the push, end the session with the commits local and report them in the PR Readiness section as not pushed, and in the step 11 report's `## ⚠ Needs you` block.
+   - Run the push-policy check before the push. `spell-commit-work` step 9a runs the same check; run it once per push, not twice. It also governs step 10's remote branch deletions. If it stops the push, end the session with the commits local and report them in the PR Readiness section as not pushed, and in the step 11 report's `## 🚧 Action required` block.
 
      <!-- fragment:push-policy-check:start -->
      **Push-policy check (ARC-049) — before any push.** Read `push_policy` from the repository's `.arcane.json` at the repository root (a self-hosted source repository with no root manifest keeps it in `src/assets/.arcane.json` when that file declares `selfHosted: true`). An absent file or an absent field means `open`. The check covers every push this spell makes: a branch push, a `--force-with-lease` push, and a remote branch deletion (`git push <remote> --delete <branch>`).
@@ -217,13 +217,13 @@ Rules:
    - Skip this entire step for local-only and read-only sessions.
    - Resolve `<remote>` and `<trunk>` from observed Git/provider state: use the usable authenticated remote selected in step 9 and the merged PR's target branch (falling back to that remote's default branch). Never assume `origin` or `main`.
    - Verify through the detected provider that the PR is merged before changing branches.
-   - Then confirm each issue the PR closed is closed. That is every issue its body names after a closing keyword, every issue named after a closing keyword in its commit messages (`git log <base>..<merge-sha> --format=%B`), and every issue GitHub links to it (`gh pr view <number> --json closingIssuesReferences`). Check each one's state with `gh issue view <number> --json state,stateReason`. If GraphQL is unavailable, use REST: `gh api repos/<owner>/<repo>/issues/<number> --jq '.state,.state_reason'` for the state. Then treat as linked every issue that follows a closing keyword in the PR body (ignore any negation) and any issue the PR references whose `closed` event (`gh api repos/<owner>/<repo>/issues/<number>/events`) falls within a minute of the PR's `merged_at`. A merge closes every issue that directly follows a closing keyword, even inside a negation: "does not close #N" closes #N. List any issue still open under the closure report's `## ⚠ Needs you`, or, once the diff check below passes, close it with a comment naming the merged PR.
+   - Then confirm each issue the PR closed is closed. That is every issue its body names after a closing keyword, every issue named after a closing keyword in its commit messages (`git log <base>..<merge-sha> --format=%B`), and every issue GitHub links to it (`gh pr view <number> --json closingIssuesReferences`). Check each one's state with `gh issue view <number> --json state,stateReason`. If GraphQL is unavailable, use REST: `gh api repos/<owner>/<repo>/issues/<number> --jq '.state,.state_reason'` for the state. Then treat as linked every issue that follows a closing keyword in the PR body (ignore any negation) and any issue the PR references whose `closed` event (`gh api repos/<owner>/<repo>/issues/<number>/events`) falls within a minute of the PR's `merged_at`. A merge closes every issue that directly follows a closing keyword, even inside a negation: "does not close #N" closes #N. List any issue still open under the closure report's `## 🚧 Action required`, or, once the diff check below passes, close it with a comment naming the merged PR.
    - **A closed issue is not evidence its change shipped.** For each issue above, confirm the merged diff contains the change that issue asked for:
      - Read the issue (`gh issue view <number> --json title,body`, or REST), then the diff (`gh pr diff <number>`).
      - Name the file that carries the requested change. If you cannot name one, treat the change as missing.
      - A diff that touches only tracking files (`FEEDBACK.md`, the journal, the handoff, `CHANGELOG.md`, `.arcane/delegations.json`) never counts as the change.
      - Reopen the issue only when all of these hold: its `closed` event falls within a minute of this PR's merge; its state reason is `completed`; and the change is not already on `<trunk>` from an earlier PR (`git log <trunk> --grep '#<number>'`). When they hold, reopen the issue with a comment naming the merged PR and listing what is missing, or which part, if only part shipped.
-     - When you cannot reopen it (permissions), list it under the closure report's `## ⚠ Needs you` instead.
+     - When you cannot reopen it (permissions), list it under the closure report's `## 🚧 Action required` instead.
      - Never report such an issue as done.
    - **Determine the isolation primitive first (ARC-028 R8).** Run both of these and compare:
      ```bash
@@ -254,23 +254,35 @@ Rules:
 
 Output format:
 
-<!-- fragment:needs-you:start -->
-**Needs you — required operator actions.** When this run leaves an action that only the operator can take, and the work is not correct or complete until it is taken, report it in one block at the very top of the final report, before every other section and before any optional next step:
+<!-- fragment:action-required:start -->
+**Action required — what only the operator can do.** When this run leaves an action that only the operator can take, report it in one block at the very top of the final report, before every other section and before any optional next step. The block exists because these are the operator's decisions to make, not because the agent is stuck: write it as a hand-off of authority, never as a plea for help. Frame it with a horizontal rule above and below, so it stands apart in a terminal as well as on a rendered page:
 
 ```markdown
-## ⚠ Needs you
+---
+
+## 🚧 Action required
+
+**Now**
+
+- <exactly what to do: the command, the link, or the question> — <why only the operator can do it>
 
-- <exactly what to do: the command, the link, or the question> — <why the agent cannot do it itself>
+**When you're at your desk**
+
+- <exactly what to do> — <why only the operator can do it>
+
+---
 ```
 
-- **What belongs in it:** an action the work needs that only the operator can take — approving or merging a pull request, accepting a decision record, answering a question the work is waiting on, confirming a `guarded` push, running an interactive command such as `spell unblock-push`, or a step on an external platform the agent cannot reach. An optional suggestion, a next spell to run, or anything the agent could do itself is not a required action and stays out of the block.
-- **One line per action.** Say exactly what to do, then, after the dash, why the agent cannot do it. Write the command, link or question out in full; never point elsewhere with "see above".
+- **What belongs in it:** an action only the operator can take — approving or merging a pull request, accepting a decision record, answering a question the work is waiting on, confirming a `guarded` push, running an interactive command such as `spell unblock-push`, or a step on an external platform the agent cannot reach. An optional suggestion, a next spell to run, or anything the agent could do itself is not a required action and stays out of the block.
+- **Two tiers, one block.** **Now** holds what the work is not correct or complete without. **When you're at your desk** holds what only the operator can do but that can wait: a permission rule, a leftover remote branch, a credential to set up. Leave out a tier that has nothing in it; never split the tiers into two blocks.
+- **One line per action.** Say exactly what to do, then, after the dash, why only the operator can do it. Write the command, link or question out in full; never point elsewhere with "see above".
 - **Never only among optional steps.** An action required for correctness is never listed only under next steps, suggestions, `Carry Forward` or `What's Next?`. It may be repeated there, but it always appears in this block.
-- **Omit it when empty.** When nothing needs the operator, leave the block out entirely: no heading and no "None" line.
+- **Done items stay, struck through.** Within one session, once an item has been listed, keep it in every later report of the block; when the operator has done it, strike it through (`~~<the line>~~`) rather than dropping it, so progress shows and nothing disappears silently. The session's close carries only the open items forward.
+- **Omit it when empty.** When nothing is left for the operator and nothing was struck through this session, leave the block out entirely: no heading, no rules and no "None" line.
 - **Every final report.** The block belongs in whatever report ends the run, including a report written when the spell stops early.
-- **Report it to the presence channel.** When the block is not empty, also run `spell presence report --status waiting --needs-you "<line 1>" --needs-you "<line 2>"`, one flag per line of the block; with no presence channel configured on this machine the command prints nothing and exits 0, so the block itself and the rest of the run are unchanged.
+- **Report the Now tier to the presence channel.** When the **Now** tier has open items, also run `spell presence report --status waiting --required-action "<line 1>" --required-action "<line 2>"`, one flag per open line of that tier; the other tier is not blocking and is not reported. With no presence channel configured on this machine the command prints nothing and exits 0, so the block itself and the rest of the run are unchanged.
 - Enforcement: explicitly advisory prose (ARC-023) — no check reads a spell's actual output for this block; it holds by these instructions alone.
-<!-- fragment:needs-you:end -->
+<!-- fragment:action-required:end -->
 
 ## Session Closure
 

package/dist/assets/.arcane/spells/spell-commit-work.md

@@ -32,7 +32,7 @@ in the user store opens it. Report with the CLI only; never pass a token on the
 never write a repository file to report.
 
 - At the start of this spell: `spell presence report --spell <spell-id> --status working --task "<the task in one line>"`.
-- When this spell's output carries a `## ⚠ Needs you` block: `spell presence report --status waiting --needs-you "<line 1>" --needs-you "<line 2>"`, one flag per line; the block itself is unchanged.
+- When this spell's output carries a `## 🚧 Action required` block with open **Now** items: `spell presence report --status waiting --required-action "<line 1>" --required-action "<line 2>"`, one flag per open Now line; the block itself is unchanged.
 - At a checkpoint worth showing (a commit made, a story passed): `spell presence report --status working --task "<what is now happening>"`.
 - When the session closes: `spell presence end`.
 
@@ -283,23 +283,35 @@ Workflow:
 
 Output format after execution:
 
-<!-- fragment:needs-you:start -->
-**Needs you — required operator actions.** When this run leaves an action that only the operator can take, and the work is not correct or complete until it is taken, report it in one block at the very top of the final report, before every other section and before any optional next step:
+<!-- fragment:action-required:start -->
+**Action required — what only the operator can do.** When this run leaves an action that only the operator can take, report it in one block at the very top of the final report, before every other section and before any optional next step. The block exists because these are the operator's decisions to make, not because the agent is stuck: write it as a hand-off of authority, never as a plea for help. Frame it with a horizontal rule above and below, so it stands apart in a terminal as well as on a rendered page:
 
 ```markdown
-## ⚠ Needs you
+---
+
+## 🚧 Action required
+
+**Now**
+
+- <exactly what to do: the command, the link, or the question> — <why only the operator can do it>
 
-- <exactly what to do: the command, the link, or the question> — <why the agent cannot do it itself>
+**When you're at your desk**
+
+- <exactly what to do> — <why only the operator can do it>
+
+---
 ```
 
-- **What belongs in it:** an action the work needs that only the operator can take — approving or merging a pull request, accepting a decision record, answering a question the work is waiting on, confirming a `guarded` push, running an interactive command such as `spell unblock-push`, or a step on an external platform the agent cannot reach. An optional suggestion, a next spell to run, or anything the agent could do itself is not a required action and stays out of the block.
-- **One line per action.** Say exactly what to do, then, after the dash, why the agent cannot do it. Write the command, link or question out in full; never point elsewhere with "see above".
+- **What belongs in it:** an action only the operator can take — approving or merging a pull request, accepting a decision record, answering a question the work is waiting on, confirming a `guarded` push, running an interactive command such as `spell unblock-push`, or a step on an external platform the agent cannot reach. An optional suggestion, a next spell to run, or anything the agent could do itself is not a required action and stays out of the block.
+- **Two tiers, one block.** **Now** holds what the work is not correct or complete without. **When you're at your desk** holds what only the operator can do but that can wait: a permission rule, a leftover remote branch, a credential to set up. Leave out a tier that has nothing in it; never split the tiers into two blocks.
+- **One line per action.** Say exactly what to do, then, after the dash, why only the operator can do it. Write the command, link or question out in full; never point elsewhere with "see above".
 - **Never only among optional steps.** An action required for correctness is never listed only under next steps, suggestions, `Carry Forward` or `What's Next?`. It may be repeated there, but it always appears in this block.
-- **Omit it when empty.** When nothing needs the operator, leave the block out entirely: no heading and no "None" line.
+- **Done items stay, struck through.** Within one session, once an item has been listed, keep it in every later report of the block; when the operator has done it, strike it through (`~~<the line>~~`) rather than dropping it, so progress shows and nothing disappears silently. The session's close carries only the open items forward.
+- **Omit it when empty.** When nothing is left for the operator and nothing was struck through this session, leave the block out entirely: no heading, no rules and no "None" line.
 - **Every final report.** The block belongs in whatever report ends the run, including a report written when the spell stops early.
-- **Report it to the presence channel.** When the block is not empty, also run `spell presence report --status waiting --needs-you "<line 1>" --needs-you "<line 2>"`, one flag per line of the block; with no presence channel configured on this machine the command prints nothing and exits 0, so the block itself and the rest of the run are unchanged.
+- **Report the Now tier to the presence channel.** When the **Now** tier has open items, also run `spell presence report --status waiting --required-action "<line 1>" --required-action "<line 2>"`, one flag per open line of that tier; the other tier is not blocking and is not reported. With no presence channel configured on this machine the command prints nothing and exits 0, so the block itself and the rest of the run are unchanged.
 - Enforcement: explicitly advisory prose (ARC-023) — no check reads a spell's actual output for this block; it holds by these instructions alone.
-<!-- fragment:needs-you:end -->
+<!-- fragment:action-required:end -->
 
 ## Commit Complete