@zalom/plastic 1.3.0 → 1.4.1

package/skills/auto/SKILL.md

@@ -39,7 +39,7 @@ ruby ~/.plastic/scripts/roadmap-next --roadmaps-dir <tier>/roadmaps
 
 Branch on `state`:
 - `dispatchable`: work its `dispatchable_queue` in `rank` order (the head is the next batch
-  entry). These are the current batch's `queued` intents, parallel-safe within the wave.
+  entry). These are the current batch's `queued` intents, parallel-safe within the batch.
 - `in_flight`: the frontier batch is still delivering. Report it and wait. Do NOT dispatch a
   later batch and do NOT fall through to the dashboard, the roadmap is live.
 - `none` or `exhausted`: no roadmap, or nothing left to dispatch. Fall back to the dashboard
@@ -93,13 +93,15 @@ edited before the plan exists (the gate applies to YOU, the orchestrator):
 
 ```bash
 ruby -r ~/.plastic/scripts/lib/bridge -e \
-  'Bridge.arm_auto(ENV["CLAUDE_CODE_SESSION_ID"], intent_id: "<ID>", intent_dir: "<STORE>/<dir>", store: "<STORE>", name: "<name>")'
+  'codex=ENV["CODEX_THREAD_ID"].to_s.strip; claude=ENV["CLAUDE_CODE_SESSION_ID"].to_s.strip; harness=!codex.empty? ? "codex" : (!claude.empty? ? "claude" : nil); session=!codex.empty? ? codex : (!claude.empty? ? claude : nil); Bridge.arm_auto(session, intent_id: "<ID>", intent_dir: "<STORE>/<dir>", store: "<STORE>", name: "<name>", harness: harness, agent: "plastic-enforcer", thread: (!codex.empty? ? codex : nil))'
 ```
 
 Replace `<ID>`, `<STORE>` (e.g. `~/.plastic/projects/<slug>/store` or `~/.plastic/store`),
 `<dir>` (the `ID--slug` directory), and `<name>`. The first argument is the session id you
-want the bridge keyed by: pass the hook stdin `session_id` when you have it, otherwise
-`ENV["CLAUDE_CODE_SESSION_ID"]`, otherwise `nil`. Arming always succeeds and acquires the
+want the bridge keyed by: pass the hook stdin `session_id` when you have it. The executable
+snippet trusts a nonblank `CODEX_THREAD_ID` as Codex, otherwise a nonblank
+`CLAUDE_CODE_SESSION_ID` as Claude, otherwise leaves harness and thread unknown. Never guess
+identity from an absent runtime variable. Arming always succeeds and acquires the
 durable `delivery.lock` in the intent dir. For the `resolve_session` fallback chain
 (why arming never needs a non-empty session env var, and what the lock ownership model
 implies for later tool calls) read `references/end-tail.md`.
@@ -148,12 +150,33 @@ The enforcer's session owns the delivery lock. Per-stage specialists run in
 their own sessions and would be denied by the lock gate, so register each one
 as a delegate before (or when) it needs to write into the intent dir:
 
-1. Instruct each spawned specialist to report its session id
-   (`CLAUDE_CODE_SESSION_ID`) in its first message.
+1. Instruct each spawned specialist to report its session id and runtime identity in its first
+   message: `CODEX_THREAD_ID` for Codex, or `CLAUDE_CODE_SESSION_ID` for Claude. Use the
+   specialist/hook identity when known; never infer a harness or model from missing context.
 2. As the lock owner, run:
-   `ruby ~/.plastic/scripts/plastic-lock delegate --delegate <specialist-session-id>`
+   `ruby ~/.plastic/scripts/plastic-lock delegate --intent-dir <intent-dir> --delegate <specialist-session-id> --harness <specialist-harness-when-known> --agent <role> --model <resolved-model-when-known> --thread <reported-CODEX_THREAD_ID-when-Codex>`
+   Omit `--harness`, `--model`, or `--thread` when that value is unknown; `--agent <role>` is
+   always known from the dispatch roster.
 3. If a specialist hits a lock-gate deny, the deny message names this exact
    command; run it and have the specialist retry.
+4. Immediately after the specialist returns, and before validating or dispatching
+   the next handoff, classify the return and record its activity status as the owner:
+   - `finished` means the specialist returned a usable completion report, whether
+     agent-authored or synthesized through `scripts/agent-report`.
+   - `failed` means the specialist returned blocked, errored, or without a usable
+     completion report that can be synthesized.
+5. Record the classification with exactly one of:
+   ```bash
+   ruby ~/.plastic/scripts/plastic-lock delegate --intent-dir <intent-dir> \
+     --delegate <specialist-session-id> --status finished --harness <same-specialist-harness-when-known> \
+     --agent <same-role> --model <same-resolved-model-when-known> --thread <same-CODEX_THREAD_ID-when-Codex>
+   ruby ~/.plastic/scripts/plastic-lock delegate --intent-dir <intent-dir> \
+     --delegate <specialist-session-id> --status failed --harness <same-specialist-harness-when-known> \
+     --agent <same-role> --model <same-resolved-model-when-known> --thread <same-CODEX_THREAD_ID-when-Codex>
+   ```
+   Apply the same omission rule to unknown values on terminal status commands.
+   A failed specialist stops that handoff under the normal blocker/error procedure;
+   never dispatch the next specialist first.
 
 Only the owner can delegate. Delegates cannot re-delegate or release.
 
@@ -305,19 +328,25 @@ During initial project creation, all decisions are non-destructive by definition
    - Update `chain` in the current intent's frontmatter
 6. Run the mechanical close through `plastic-intent-ending`: it owns steps 1-6 of the Done
    procedure (outcome/INDEX/savepoint/commit, disarm, and the QMD reindex last) as ONE
-   delegation, not five separate one-liners restated here. Run its backing script for the
-   outcome/INDEX/savepoint/commit core, passing `--index-note` with a rich Completed/
-   Abandoned entry description (mode/tier, what shipped or why abandoned, suite result):
+   delegation, not five separate one-liners restated here. `scripts/end-intent` now performs
+   steps 1-5 itself, INCLUDING disarm (worktree release plus clearing `delivery.lock`): a
+   single call closes the intent AND clears its lock, so exit 0 means both are done. Pass
+   `--session` (this session's id, or rely on the `CLAUDE_CODE_SESSION_ID` fallback) so
+   disarm resolves the right bridge, and `--index-note` with a rich Completed/Abandoned entry
+   description (mode/tier, what shipped or why abandoned, suite result):
    ```bash
    ruby ~/.plastic/scripts/end-intent --store <store_path> --id <ID> --disposition delivered \
+     --session "$CLAUDE_CODE_SESSION_ID" \
      --index-note "<mode, tier>; <what shipped>; <suite result>"
    ```
-   (Use `--disposition abandoned` when the intent is being moved to `## Abandoned`.) Then
-   follow `plastic-intent-ending`'s Step 5 (disarm: `Bridge.disarm_auto` on this auto/curator
-   path, the plain-remove branch) and Step 6 (QMD reindex, async, last) exactly as that skill
-   states them. Never leave an orphaned worktree; run `git worktree prune` on a stale
-   reference. If any of this ever needs to change, change `plastic-intent-ending`, not this
-   skill.
+   (Use `--disposition abandoned` when the intent is being moved to `## Abandoned`.) A
+   non-zero exit needs attention before moving on: 4 means a live foreign session holds the
+   lock (back off), 5 means the code worktree is dirty (commit/stash first, or pass
+   `--discard-worktree-changes` deliberately), 3 means disarm ran but the lock is still
+   present (run `/plastic-doctor check the lock status`). Only Step 6 (QMD reindex, async,
+   last) remains a separate action after this call succeeds. Never leave an orphaned
+   worktree; run `git worktree prune` on a stale reference. If any of this ever needs to
+   change, change `plastic-intent-ending`, not this skill.
 7. Notify user (Done briefing): brief per `references/human-report-contract.md`
     (State: the delivered impact; Risk: residual risk; Call: the decision left to you, merge,
     release, or accept). See `outcome.md` for details.

package/skills/auto/references/agent-architecture.md

@@ -81,6 +81,13 @@ account therefore always exists: agent-authored when present, deterministically
 otherwise. This structures the finish notification only; in-flight observations stay in
 `## Insights`, no progress chatter is added.
 
+Immediately after a specialist returns and before the next handoff, the enforcer records the
+delegate's activity through `plastic-lock delegate --intent-dir <intent-dir> --delegate <id>
+--status finished|failed`. `finished` requires a usable agent-authored or synthesized completion
+report. A blocked or errored return, or one with no report that can be synthesized, is `failed`
+and stops the handoff under the normal error procedure. Activity status is descriptive and does
+not revoke the registered delegate's authorization.
+
 ### Gate Ownership
 
 The enforcer arms and verifies the lifecycle gate, then gates every stage transition.

package/skills/auto/references/end-tail.md

@@ -33,19 +33,33 @@ purge-eligible. Disarming also purges stale bridge files from the temp directory
 automatically (it keeps the current bridge, any live run, and any bridge whose intent
 still holds a delivery lock), so no manual `/tmp` cleanup is needed.
 
-**Worktree cleanup (mandatory, intent 73c3).** Disarming performs the worktree release:
-`disarm_auto` calls `Worktree.release`, which removes both per-intent worktrees (the code
-worktree under `<repo>/.claude/worktrees/{id}--{slug}` and the paired store worktree under
-`<plastic_home>/.worktrees/{id}--{slug}`), prunes both repos, and clears the worktree block
-from the bridge. This is the plain remove path: the disarm route does NOT merge, so use it
-only when no release merges the branch (the branch survives and can be reclaimed).
-
-When the work is being shipped through a release, do NOT rely on this plain remove. The
-release path (Completion step 4, via `plastic-releasing`) is responsible for merging the
-intent's code branch (`plastic/{id}--{slug}`) back to the repo's default branch BEFORE the
-worktree is removed, so the integrated work is not lost. It does this with
-`Worktree.finish(bridge_data, merge: true)` (merge-then-remove). Never leave an orphaned
-worktree, and run `git worktree prune` if you hit a stale reference.
+**Mechanized since intent 188.** `scripts/end-intent` performs this disarm itself, as its
+own step 5, after steps 1-4 (outcome/INDEX/savepoint/commit) commit. No agent needs to run
+a separate `Bridge.disarm_auto` one-liner any more on the auto mode / curator path: the
+single `end-intent` call in `SKILL.md`'s Completion section already does it. A pre-flight
+lock guard (before anything is written) refuses on a live foreign session (exit 4) and
+reclaims a stale foreign lock automatically (audited to savepoint.md); a dirty code
+worktree refuses before removal (exit 5, `--discard-worktree-changes` overrides
+deliberately); and the durable lock file is checked again after disarm, never merely
+trusted (exit 3 if it is somehow still present).
+
+**Worktree cleanup (mandatory, intent 73c3).** `end-intent`'s step 5 calls
+`Bridge.disarm_auto` by default, which calls `Worktree.release`, which removes both
+per-intent worktrees (the code worktree under `<repo>/.claude/worktrees/{id}--{slug}` and
+the paired store worktree under `<plastic_home>/.worktrees/{id}--{slug}`), prunes both
+repos, and clears the worktree block from the bridge. This is the plain remove path: the
+disarm route does NOT merge, so use it only when no release merges the branch (the branch
+survives and can be reclaimed).
+
+When the work is being shipped through a release, do NOT rely on this plain remove.
+`skills/releasing/SKILL.md` reorders its own two steps for exactly this reason (intent 188,
+D7): its worktree-merge step now runs BEFORE its `end-intent` call, merging the intent's
+code branch (`plastic/{id}--{slug}`) back to the repo's default branch BEFORE the worktree
+is removed, via `Worktree.finish(bridge_data, merge: true)` (merge-then-remove), so the
+integrated work is not lost. By the time `end-intent`'s own step 5 runs afterward, the
+worktree is already gone (a harmless no-op) and only the delivery lock is left to clear,
+correctly, for the first time on that path. Never leave an orphaned worktree, and run
+`git worktree prune` if you hit a stale reference.
 
 ## QMD reindex ordering rationale
 

package/skills/dashboard/SKILL.md

@@ -33,14 +33,19 @@ ruby ~/.plastic/scripts/dashboard.rb [continue|project <slug>] --data
 - `continue` (default) → the **global** board payload (`mode: "global"`).
 - `project <slug>` → that **project** board payload (`mode: "project"`).
 
-The payload is read-only JSON. Global-board fields: `date`, `store_health`, `recently_worked`,
-`next_work`, `counts`, `projects`, `project_totals`. Project-board fields: `slug`, `store_health`,
-`description`, `recently_worked`, `next_work`, `counts`, `active`, `future`. Each list carries
-cell-ready fields for its table: `next_work` rows are
+The payload is read-only JSON. Global-board fields: `date`, `store_health`, `summary`,
+`next_work`, `next_total`, `next_shown`, `counts`, `projects`, `project_totals`, `footer`.
+Project-board fields: `slug`, `store_health`, `description`, `summary`, `counts`, `active`,
+`active_total`, `active_shown`, `next_work`, `next_total`, `next_shown`, `footer`. `summary`
+and `footer` are finished prose strings (2-3 sentences and one line respectively), built in
+`dashboard.rb` and substituted verbatim, exactly like `{{date}}`/`{{description}}` already
+are - never re-worded or re-derived by the skill. Each list carries cell-ready fields for
+its table: `next_work` rows are
 `{id, intent, scope, lifecycle, value, disposition, flags, what, flags_label, line}`;
-`recently_worked` rows carry `{id, status, glyph, last_accessed_at, what, state, scope, line}`;
-`active`/`future` rows carry `{id, intent, created, bullet, scope, what, stage, line}`. The `what`,
-`scope`, and `flags_label` cell fields arrive pipe-escaped and whitespace-normalized.
+`active` rows carry
+`{id, intent, created, bullet, scope, what, stage, worker, activity, line}`. The `what`,
+`scope`, `worker`, `activity`, and `flags_label` cell fields arrive pipe-escaped and
+whitespace-normalized.
 
 Each board load runs the scoped store check (`doctor --store <scope>`): the global board runs
 `--store global` and a project board runs `--store <slug>`. The result rides in the payload as
@@ -57,24 +62,42 @@ Templates live in this skill's `templates/` directory:
 
 Fill mechanically, no rewriting, no re-sorting:
 - `{{a.b.count}}` → the integer (e.g. `counts.active` = that count).
-- `{{<list>.rows}}` → the four intent lists (`recently_worked`, `next_work`, `active`, `future`)
-  render as **Markdown table rows**. The template hard-codes each table's header and separator;
-  this placeholder becomes one data row per list entry, joined with real newlines, in that table's
-  fixed column order (below). Drop each cell from the named payload field **verbatim**: cells
-  arrive pre-escaped and whitespace-normalized from the script (pipes escaped as `\|`), so never
-  re-escape, re-truncate, or reword them. Never emit `<br>`.
-  - `recently_worked` (global) → `| {id} | {what} | {state} | {scope} |`
-  - `recently_worked` (project) → `| {id} | {what} | {state} |`
+- `{{<list>.rows}}` → the two intent lists (`active`, `next_work`) render as **Markdown table
+  rows**. The template hard-codes each table's header and separator; this placeholder becomes
+  one data row per list entry, joined with real newlines, in that table's fixed column order
+  (below). Drop each cell from the named payload field **verbatim**: cells arrive pre-escaped
+  and whitespace-normalized from the script (pipes escaped as `\|`), so never re-escape,
+  re-truncate, or reword them. Never emit `<br>`.
   - `next_work` → `| {id} | {what} | {value} | {disposition} | {flags_label} |`
-  - `active` → `| {id} | {what} | {stage} |`
-  - `future` → `| {id} | {what} |`
-  Overflow entry (empty `id`, `what` = `+N more`) → one row with `+N more` in the Id column and
-  every other cell blank. Empty list → one full-width row with `_(none)_` in the Id column and
-  every other cell blank, matching that table's column count (e.g. `| _(none)_ | | | | |` for
-  the 5-column next_work table, `| _(none)_ | |` for the 2-column future table).
-- `{{projects.lines}}` → the project rollup stays **prose**, one line per project (not a table):
+  - `active` → `| {id} | {what} | {stage} | {worker} | {activity} |`
+  Empty list → one full-width row with `_(none)_` in the Id column and every other cell blank,
+  matching that table's column count (e.g. `| _(none)_ | | | | |` for the 5-column next_work
+  table, `| _(none)_ | | | |` for the 5-column active table). Neither list carries an overflow
+  "+N more" row anymore (D5, intent 202): the true pool size rides on the payload as
+  `active_total`/`next_total` (shown counts as `active_shown`/`next_shown`), and `{{footer}}`
+  states it in prose instead.
+- `{{projects.lines}}` (global board only) → the project rollup stays **prose**, one line per
+  project (not a table):
   `- **{slug}**: {description}, active {active}, done {done}, future {future}, last accessed {last_accessed_at[0,10]}`.
-- Scalars (`{{date}}`, `{{slug}}`, `{{description}}`) → substitute verbatim.
+- Scalars (`{{date}}`, `{{slug}}`, `{{summary}}`, `{{footer}}`) → substitute verbatim. `summary`
+  and `footer` are finished prose built in `dashboard.rb`; do not rewrite, shorten, or
+  re-derive them from the counts - that is exactly the non-determinism D5 rules out.
+
+### Paging (conversational, D4)
+
+The board shows a short page by default (Active capped at 3, Next-work at 5). When the
+user asks for "more" or "all", re-invoke Step 1 with an explicit flag and re-fill the
+template with the new payload - nothing is persisted to disk, the offset lives only in the
+chat turn:
+- "all" → add `--all` (lifts both caps to unbounded; the footer then shows equal shown/total).
+- "more" → add `--limit-active N`/`--limit-next N` with a larger `N` for whichever list the
+  user is paging.
+
+For a real, own-terminal pager instead, point the owner at `--plain`:
+`ruby ~/.plastic/scripts/dashboard.rb project <slug> --plain | less` (or `continue --plain`
+for the global board). `--plain` prints the full, uncapped board as plain text with no
+Markdown table syntax; it is a separate CLI mode from `--data`, not something this skill
+fills a template from.
 
 ### Step 3 — Present it (mandatory, every invocation)
 
@@ -139,8 +162,8 @@ intentional change means the skill is broken.
 
 ## Notes
 
-- The four intent lists (recently worked, active, future, next work) render as Markdown tables;
-  the narrative wrappers, counts, and the project rollup stay prose. No Value x Effort grid
+- The two intent lists (active, next work) render as Markdown tables; the prose summary,
+  footer, counts, and the project rollup stay prose (intent 202). No Value x Effort grid
   returns. Never emit `<br>`.
 - Clusters (Zettelkasten grouping in INDEX.md) are intentionally not rendered.
 - Additive: changes no core lifecycle, gate, or cycle logic.

package/skills/dashboard/evals/evals.json

@@ -22,14 +22,14 @@
       "id": 2,
       "scope": "behavior",
       "set": "validation",
-      "prompt": "How do the four intent lists render on the Markdown boards?",
-      "expected_output": "recently_worked, next_work, active, and future render as Markdown tables (fixed columns: next_work Id|What|Value|Disposition|Flags; active Id|What|Stage; future Id|What; recently_worked Id|What|State, plus a Scope column on the global board). The narrative wrappers, counts, and the projects rollup stay prose; no Value x Effort grid. Cells arrive pre-escaped from the payload and are dropped verbatim.",
+      "prompt": "How does the project board render after intent 202 (short by default, paged on request)?",
+      "expected_output": "The project board shows, in order, and nothing else: a 2-3 sentence prose summary of what was delivered most recently (built in dashboard.rb from completed/completed_on data, not the 24h-windowed recently_worked), an Active table capped at 3 rows (Id|What|Stage, ordered lifecycle-stage descending with a savepoint tie-break), a Next-work table capped at 5 rows (Id|What|Value|Disposition|Flags), and a one-line footer stating true totals (e.g. '3 of 12 active, 5 of 47 next work') plus how to see everything. The raw Future table and its {{future.rows}} placeholder, and the separate Recently-worked table, are both gone from dashboard-project.md. dashboard-global.md carries the equivalent fix (D6): a prose summary in place of its recently-worked table, the same honest footer, and the same --limit-active/--limit-next/--all/--plain mechanics.",
       "files": ["skills/dashboard/templates/dashboard-global.md", "skills/dashboard/templates/dashboard-project.md", "skills/dashboard/SKILL.md"],
       "assertions": [
         {
           "type": "convention",
-          "check": "the four intent lists render as Markdown tables with the fixed columns; wrappers and the projects rollup stay prose; no grid",
-          "observed": "templates hard-code table headers plus {{list.rows}} for recently_worked/next_work/active/future; SKILL.md Step 2 documents the fixed column order and verbatim pre-escaped cell fill; projects stays {{projects.lines}} prose",
+          "check": "project board template has summary+active+next_work+footer only (no future, no recently_worked table); global template has summary+footer added; SKILL.md documents the new payload fields and CLI flags",
+          "observed": "templates carry {{summary}}, {{active.rows}} (Id|What|Stage), {{next_work.rows}} (Id|What|Value|Disposition|Flags), {{footer}}; {{future.rows}} and the recently-worked table are removed from both; SKILL.md Step 1/2 document summary/footer/active_total/active_shown/next_total/next_shown and --limit-active/--limit-next/--all/--plain",
           "result": "pass"
         }
       ]

package/skills/dashboard/templates/dashboard-global.md

@@ -1,10 +1,6 @@
 # 🧩 Plastic · Global Board, {{date}}
 
-**Recently worked** (last 24h)
-
-| Id | What | State | Scope |
-| --- | --- | --- | --- |
-{{recently_worked.rows}}
+{{summary}}
 
 ## Where we are
 
@@ -19,4 +15,6 @@
 | --- | --- | --- | --- | --- |
 {{next_work.rows}}
 
+{{footer}}
+
 **What would you like to work on next?** (type an **intent id**, a **project name**, or anything **new** you'd like to start)

package/skills/dashboard/templates/dashboard-project.md

@@ -1,31 +1,19 @@
 # 📦 {{slug}} · Project Board, {{date}}
 
-{{description}}
-
-**Recently worked** (last active work, last 24h)
-
-| Id | What | State |
-| --- | --- | --- |
-{{recently_worked.rows}}
-
-## Intents, active {{counts.active}}, done {{counts.done}}, future {{counts.future}}
+{{summary}}
 
 **Active**
 
-| Id | What | Stage |
-| --- | --- | --- |
+| Id | What | Stage | Worker | Activity |
+| --- | --- | --- | --- | --- |
 {{active.rows}}
 
-**Future**
-
-| Id | What |
-| --- | --- |
-{{future.rows}}
-
-## Most-valuable next work
+**Most-valuable next work**
 
 | Id | What | Value | Disposition | Flags |
 | --- | --- | --- | --- | --- |
 {{next_work.rows}}
 
+{{footer}}
+
 **What would you like to work on next?** (type an **intent id**, or **global** to go back)

package/skills/install/SKILL.md

@@ -103,10 +103,10 @@ Non-interactive sessions (no tty) skip the question entirely: the install ships
 shipped default, advisor enabled with no `--advisor` flag (the `plastic-agent-advisor`
 skill's own routing falls back to `plastic-faux-advisor` at consult time).
 
-Update flow: if `advisor.enabled` or `advisor.claude.default` are already set in
-`~/.plastic/config.yml`, do not re-ask; the existing value is respected, the same
-ask-once-when-unset rule the statusline choice below already follows. Either flag can
-also be passed again on `install --reinstall` to change a prior answer.
+Update flow: pending config questions, including this one, are now announced
+generically by `plastic-update`'s Step 2, sourced from `config_asks.yml` - not
+duplicated here. A value already set by either path is never re-asked by the
+other.
 
 **Statusline**
 

package/skills/intent-creating/SKILL.md

@@ -69,6 +69,11 @@ Having a "parent" in mind does NOT automatically mean branch. Choose by meaning:
   `--sources` when it was genuinely created from / emerged from that intent's lifecycle.
   Topic similarity alone is not a `sources` edge.
 
+When a branch intent exists because a late ruling arrived AFTER its parent was already
+completed (the owner's late-ruling rule), the parent is restored to v1 via
+`scripts/restore-intent-v1`, never by a hand-run `git checkout`/revert. See `PLASTIC.md` >
+Terminal immutability for the rule and the tool.
+
 `## Links` is a DERIVED view of `sources`/`chain`. Never hand-write a `## Links` line; add the
 frontmatter edge and reproject. Links are decided by context influence (a `chain` edge has a high
 bar: the candidate's context must materially help deliver this intent), not by shared files or a

package/skills/intent-ending/SKILL.md

@@ -24,15 +24,16 @@ failure branch: only outcome.md content and the INDEX section differ.
 | 2 | INDEX.md terminal move (Active -> Completed/Abandoned) | `scripts/end-intent` |
 | 3 | savepoint `Done` bookend | `scripts/end-intent` |
 | 4 | store auto-commit | `scripts/end-intent` |
-| 5 | disarm (worktree + lock) | You, after end-intent exits 0 |
+| 5 | disarm (worktree + lock) | `scripts/end-intent` (intent 188) |
 | 6 | QMD reindex, async, LAST | You |
 | 7 | EM-to-CTO report | You |
 
-Steps 1-4 are ONE callable script, not four separate one-liners: this is
-exactly what the failure mode this intent fixes looked like (releasing hand
+Steps 1-5 are ONE callable script call, not several separate one-liners: this
+is exactly what the failure mode this intent fixes looked like (releasing hand
 authored the close in prose and dropped the savepoint bookend for two real
-deliveries). Never restate outcome/INDEX/savepoint prose inline again; call
-`scripts/end-intent`.
+deliveries; separately, one session delivered four intents back to back and
+never ran the old step-5 one-liner at all, intent 188). Never restate
+outcome/INDEX/savepoint/disarm prose inline again; call `scripts/end-intent`.
 
 ### Step 0. Precondition (the gate is section-blind, not selective)
 
@@ -55,7 +56,7 @@ for orchestrator-owned or completion-tracking items.
    (tick it if the described work is actually done, or do the remaining
    work); do not attempt outcome.md and fight the gate's deny.
 
-### Step 1-4. Run `scripts/end-intent`
+### Step 1-5. Run `scripts/end-intent`
 
 First author outcome.md for real (never leave the scaffold placeholder in
 place): copy `templates/outcome.md`, set the frontmatter to
@@ -72,40 +73,52 @@ Then call the script once:
 ```bash
 ruby ~/.plastic/scripts/end-intent \
   --store <store_path> --id <intent_id> --disposition delivered|abandoned \
+  --session "$CLAUDE_CODE_SESSION_ID" \
   --outcome-summary "<one-line ## Outcome summary for the intent file>" \
   --index-note "<rich Completed/Abandoned entry description>"
 ```
 
-This does all of steps 1-4 in order: guards outcome.md (refuses a missing,
+This does all of steps 1-5 in order: guards outcome.md (refuses a missing,
 still-placeholder, or wrong-disposition file with exit 2 and authors
 nothing), stamps the intent file's `## Outcome` section, moves the INDEX.md
 line from `## Active` to `## Completed` or `## Abandoned` (dated today,
-idempotent) with the `--index-note` text appended after the date so the
-entry stays rich, appends the savepoint `Done` bookend, and commits the
-store repo. Omit `--index-note` for a thin id+date entry, add `--no-commit`
-when a separate commit step already covers the store, and `--dry-run` to
-preview with no writes. Exit 0 is success; exit 1 is a usage or resolution
-failure; exit 2 is the outcome.md guard refusing (fix outcome.md and re-run,
-nothing was written).
-
-### Step 5. Disarm (worktree + lock)
-
-Two branches, decided by how this intent ships:
-
-- **Shipped through a release** (the `plastic-releasing` flow reached this
-  close): merge the code branch back BEFORE removing the worktrees, via
-  `Worktree.finish(bridge_data, merge: true)`. Releasing's own workflow
-  already drives this; this skill's job here is only the outcome/INDEX/
-  savepoint/commit core above.
-- **Auto mode or the curator path** (no release involved): plain remove,
-  branch survives for reclaim.
-  ```bash
-  ruby -r ~/.plastic/scripts/lib/bridge -e \
-    'Bridge.disarm_auto(ENV["CLAUDE_CODE_SESSION_ID"], intent_id: "<ID>")'
-  ```
-  `disarm_auto` releases both worktrees, clears the `delivery.lock`, and only
-  then makes the bridge purge-eligible, in that order. Never leave an
-  orphaned worktree; run `git worktree prune` on a stale reference.
+idempotent, accepting either a real em dash or a plain hyphen as the id/
+title separator on read while always emitting the real em dash on write)
+with the `--index-note` text appended after the date so the entry stays
+rich, appends the savepoint `Done` bookend, commits the store repo, and
+disarms (releases the code worktree and clears `delivery.lock`, verified
+against the durable lock file on disk, never merely trusted). Omit
+`--index-note` for a thin id+date entry, add `--no-commit` when a separate
+commit step already covers the store (this never skips disarm), and
+`--dry-run` to preview steps 1-5 with no writes.
+
+A pre-flight lock guard runs before anything is written: it resolves the
+calling session (`--session`, else `CLAUDE_CODE_SESSION_ID`, else the
+existing lock's own recorded owner, else a no-op) and checks it against any
+existing `delivery.lock`. A live foreign session refuses the whole run
+(exit 4, nothing written); a stale foreign lock is reclaimed automatically
+(audited to savepoint.md) and the run proceeds as the new owner. Before
+removing the worktree, step 5 also refuses on an unexpectedly dirty code
+worktree (exit 5, naming the worktree path) rather than force-discarding
+uncommitted changes; pass `--discard-worktree-changes` only when you mean
+to override that deliberately.
+
+On the auto mode / curator path (no release), this single call performs the
+FULL disarm (plain worktree remove, since the branch survives for later
+reclaim). On a release-shipped path, `skills/releasing/SKILL.md` merges and
+removes the worktree FIRST (its own step 8, merge-then-remove) before ever
+calling this script, so by the time this call's step 5 runs, the worktree is
+already gone (a harmless no-op) and only the lock is left to clear,
+correctly, for the first time on that path (D7).
+
+Exit codes: 0 success (the intent is closed AND its delivery lock is gone);
+1 a usage or resolution failure, OR an INDEX id that resolves to neither
+`## Active` nor the terminal section; 2 the outcome.md guard refusing (fix
+outcome.md and re-run, nothing was written); 3 steps 1-4 already committed
+but disarm could not verify the lock is gone afterward (run `/plastic-doctor
+check the lock status`); 4 a live foreign session holds the lock (back off);
+5 the code worktree is dirty (commit/stash first, or pass
+`--discard-worktree-changes` deliberately).
 
 ### Step 6. QMD reindex, LAST
 
@@ -146,6 +159,6 @@ historical record of what was planned.
 
 `plastic-releasing`, `plastic-auto`, the curator agent, `store-curating`, and
 `store-indexing` all delegate their mechanical close to this skill (or call
-`scripts/end-intent` directly for steps 1-4). None of them restate the
-outcome/INDEX/savepoint prose inline any more; if you find one that does,
-that surface has drifted and should route here instead.
+`scripts/end-intent` directly for steps 1-5). None of them restate the
+outcome/INDEX/savepoint/disarm prose inline any more; if you find one that
+does, that surface has drifted and should route here instead.

package/skills/intent-locking/SKILL.md

@@ -19,23 +19,41 @@ Run from the project (the intent resolves from this session's bridge), or pass
 
 | Verb | What it does | When |
 |---|---|---|
+| `who` | Print a compact owner, heartbeat, claim, and delegate view from durable files only | Safe human inspection; requires `--intent-dir` |
 | `status` | Report the lock file, bridge cache, freshness, agreement | Always safe; run first |
 | `fix` | Idempotent repair: rebuild lock + bridge from disk truth for THIS session. Never touches a fresh foreign lock | Interrupted work, corrupted state, /tmp wiped, legacy pid locks |
 | `release` | Owner clears the lock | Ending or abandoning a boarding |
 | `reclaim` | Explicit takeover of a STALE lock; appends an audit line to savepoint.md | The owner is gone and the lease expired |
-| `delegate` | Owner registers a subagent session under the lock (`--delegate <session-id>`) | Auto-mode orchestration |
+| `delegate` | Owner registers a subagent session and optional provenance, or marks it `finished`/`failed` | Auto-mode orchestration |
 
 ```
 ruby ~/.plastic/scripts/plastic-lock status
+ruby ~/.plastic/scripts/plastic-lock who --intent-dir <store>/<id>--<slug>
 ruby ~/.plastic/scripts/plastic-lock fix --intent-dir <store>/<id>--<slug>
 ruby ~/.plastic/scripts/plastic-lock reclaim --intent-dir <store>/<id>--<slug>
-ruby ~/.plastic/scripts/plastic-lock delegate --delegate <subagent-session-id>
+ruby ~/.plastic/scripts/plastic-lock delegate --delegate <subagent-session-id> \
+  --harness codex --agent plastic-executor --model <model> --thread <thread-id>
+ruby ~/.plastic/scripts/plastic-lock delegate --delegate <subagent-session-id> --status finished
 ```
 
+When the current controller knows its provenance, `fix` and `reclaim` accept
+`--harness`, `--agent`, `--model`, `--thread`, and `--mode auto|guided`.
+Provenance is descriptive; the session remains the authorization identity.
+
 ## Rules
 
 - `fix` exits non-zero when another session holds a FRESH lock: back off, do
   not retry in a loop. `status` shows the owner.
+- `who` is strictly read-only. It reads `delivery.lock`, its mtime, and claim
+  files; it never reads or repairs a bridge, searches transcripts, heartbeats,
+  or writes. Missing legacy provenance displays as `Unknown` rather than being
+  inferred.
+- The `delivery.lock` file mtime is the sole heartbeat and freshness truth.
+  Provenance timestamps do not replace it.
+- Only the lock owner may register delegates or mark them `finished` or
+  `failed`. Terminal status is observational and does not remove the delegate
+  session from the authorization list. Finished and failed activity history is
+  bounded to the 20 most recent terminal entries.
 - `reclaim` refuses a fresh lock. There is no silent reclaim anywhere; every
   takeover is audited in the intent's savepoint.md.
 - Acquiring a lock for new work is NOT this skill's job: board through

package/skills/intent-starting/SKILL.md

@@ -47,10 +47,10 @@ enforces it: without a held lock, mutating writes to this active intent's dir ar
    ```bash
    # guided (lock only):
    ruby -r ~/.plastic/scripts/lib/bridge -e \
-     'Bridge.arm_guided(ENV["CLAUDE_CODE_SESSION_ID"], intent_id: "<ID>", intent_dir: "<STORE>/<dir>", store: "<STORE>", name: "<name>")'
+     'codex=ENV["CODEX_THREAD_ID"].to_s.strip; claude=ENV["CLAUDE_CODE_SESSION_ID"].to_s.strip; harness=!codex.empty? ? "codex" : (!claude.empty? ? "claude" : nil); session=!codex.empty? ? codex : (!claude.empty? ? claude : nil); Bridge.arm_guided(session, intent_id: "<ID>", intent_dir: "<STORE>/<dir>", store: "<STORE>", name: "<name>", harness: harness, agent: "plastic-enforcer", thread: (!codex.empty? ? codex : nil))'
    # auto (lock + auto), then hand to plastic-auto:
    ruby -r ~/.plastic/scripts/lib/bridge -e \
-     'Bridge.arm_auto(ENV["CLAUDE_CODE_SESSION_ID"], intent_id: "<ID>", intent_dir: "<STORE>/<dir>", store: "<STORE>", name: "<name>")'
+     'codex=ENV["CODEX_THREAD_ID"].to_s.strip; claude=ENV["CLAUDE_CODE_SESSION_ID"].to_s.strip; harness=!codex.empty? ? "codex" : (!claude.empty? ? "claude" : nil); session=!codex.empty? ? codex : (!claude.empty? ? claude : nil); Bridge.arm_auto(session, intent_id: "<ID>", intent_dir: "<STORE>/<dir>", store: "<STORE>", name: "<name>", harness: harness, agent: "plastic-enforcer", thread: (!codex.empty? ? codex : nil))'
    ```
    Replace `<ID>`, `<STORE>` (`~/.plastic/projects/<slug>/store` or `~/.plastic/store`),
    `<dir>` (the `ID--slug` directory), and `<name>`.
@@ -67,8 +67,10 @@ enforces it: without a held lock, mutating writes to this active intent's dir ar
    discovery yields nothing, proceed to Why normally.
 
 **Session id resolution (verbatim from `plastic-auto`).** The first argument is the session
-id the bridge is keyed by: pass the hook stdin `session_id` when you have it, otherwise
-`ENV["CLAUDE_CODE_SESSION_ID"]`, otherwise `nil`. Both arms call `resolve_session`, which
+id the bridge is keyed by: pass the hook stdin `session_id` when you have it; in the executable
+snippets, a nonblank `CODEX_THREAD_ID` identifies Codex, otherwise a nonblank
+`CLAUDE_CODE_SESSION_ID` identifies Claude, otherwise identity remains unknown. Never infer a
+harness from an absent variable. Both arms call `resolve_session`, which
 picks the first non-empty of: the explicit id you pass → `CLAUDE_CODE_SESSION_ID` → a
 deterministic derived key (a hash of the store and intent id). It never returns nil, so the
 lock is taken even when every session env var is empty; arming prints a one-line stderr

package/skills/project-continuing/SKILL.md

@@ -104,6 +104,16 @@ state and stops, asking nothing (unchanged): it does not itself dispatch, re-ran
 roadmap. The global store and any project with no roadmap report `none`, so this board stays the
 default route for them.
 
+Intent 202 has landed on top of 149/149a: the project board is short by default. The
+Recently-worked table and the raw Future table are both gone, replaced by a 2-3 sentence
+prose summary (built in `dashboard.rb`, not by this skill) plus a one-line footer stating
+true totals. Active is capped at 3 (ordered lifecycle-stage descending, a later savepoint
+breaking a tie - D2), Next-work at 5. Conversational paging ("more"/"all") re-invokes
+`dashboard.rb ... --data` with `--limit-active`/`--limit-next`/`--all`, carrying no state on
+disk; `--plain` prints the full uncapped board as plain text for a real pager. The rule-name
+citations and the `dashboard.rb project <slug> --data` -> `dashboard-project.md` path still
+resolve.
+
 ## References
 
 - `references/board-fill.md` - the template-fill mechanics and store-health surfacing detail.