opencode-thrum-pro 0.1.6 → 0.1.8

package/assets/skills/choosing-subagent-models/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: choosing-subagent-models
-description: "Use when about to launch, spawn, or dispatch a subagent, sub-agent, or parallel agent - including the Agent/Task tool, an Explore agent, fanning out research, or any time you choose a model for a subagent. ALSO fires on every REVIEW dispatch - dispatching a reviewer, a code review, a code-quality review, a spec-compliance review, a dual review, a verify-against-plan or verify-against-source pass, or a merge-gate sub-agent. Reviewer dispatch is the HIGHEST-STAKES judgment-tier spawn and is the one most often done from memory. Enforces the role-based model tiering (opus-low orchestrators, sonnet-medium implementers and reviewers, sonnet-low sub-agents) and cheap parallel fan-out."
+description: "Use when about to launch, spawn, or dispatch a subagent, sub-agent, or parallel agent - including the Agent/Task tool, an Explore agent, fanning out research, or any time you choose a model for a subagent. ALSO fires on every REVIEW dispatch - dispatching a reviewer, a code review, a code-quality review, a spec-compliance review, a dual review, a verify-against-plan or verify-against-source pass, or a merge-gate sub-agent. Reviewer dispatch is the HIGHEST-STAKES judgment-tier spawn and is the one most often done from memory. Enforces role-based model TIERING (mechanical, judgment, orchestration) resolved to a concrete model+effort for whichever runtime you are actually running under, and cheap parallel fan-out."
 ---
 
 # Choosing Subagent Models
@@ -11,16 +11,33 @@ description: "Use when about to launch, spawn, or dispatch a subagent, sub-agent
 (e.g. `/tmp/<task>.md`); its reply to you is only a summary. Put this
 in the prompt.**
 
-## Pin every spawn. The floor depends on the agent's ROLE.
-
-Every subagent you spawn MUST pass an explicit `model:` (plus effort where the
-runtime supports it). Omitting it runs the subagent on YOUR model (Opus) — the
-single biggest avoidable cost leak in agent work.
-
-**Haiku is banned entirely.** There is no
-mechanical-task carve-out anymore — lint runs, grep-and-collect, file maps,
-config edits, and all other "simple" work now dispatch at sonnet-low, not Haiku.
-Never select Haiku on own judgment — use sonnet-low instead.
+## Pick a TIER by role/task, then resolve it for YOUR runtime. Pin every spawn.
+
+Model selection here is two steps, always in this order:
+
+1. **Pick the semantic tier** by the spawned agent's role/task — one of three,
+   named identically everywhere in the fleet (Go constants, role templates,
+   this doc): **`mechanical`** (rote/find-replace/grep-and-collect/lint/file-maps —
+   the cheapest tier), **`judgment`** (the default tier for implementers,
+   reviewers, verifiers, researchers — real analysis, not busywork), and
+   **`orchestration`** (orchestrator/coordinator tier — never spawned for a
+   sub-agent, only ever the operator's own agent or a skill that explicitly
+   names it for one step).
+2. **Resolve that tier to a concrete `model:` + `effort:` for the runtime you
+   are actually running under** — via that runtime's own preset
+   (`RuntimePreset.TierModels`) or operator config (`runtime.role_models`);
+   see "Where the tier-model mapping lives" below. Never assume Claude's
+   model names (`sonnet`, `opus`, `haiku`) apply —
+   a Codex or OpenCode agent reading this same file has no such models, and
+   passing one either errors or silently falls back to the runtime's own
+   default (see "Never let an unresolved pin fall through" below).
+
+Every subagent you spawn MUST pass an explicit, resolved `model:` (plus effort
+where the runtime supports it). Omitting it runs the subagent on YOUR model —
+the single biggest avoidable cost leak in agent work.
+
+Haiku 5.5 is eligible for summarization and mechanical work.
+Read the effective model and effort at use from `runtime.role_models`.
 
 ### Read the tiers at the moment of use
 
@@ -39,36 +56,45 @@ from `runtime.role_models` for the target role, per this skill.
 ### Agent tiers
 
 Effort tier governs whether an agent does the hard thing or the expedient thing.
-These are the tiers now:
-
-| Role | Model / Effort |
-| ---------------------------- | ------------------- |
-| **Orchestrator** | **`opus` / low** |
-| **Implementer** | **`sonnet` / medium** |
-| **Verifier / reviewer** | **`sonnet` / medium** |
-| **Sub-agent** (investigation, grep, mechanical) | **`sonnet` / low** |
-
-- **`model: "sonnet"` @ low effort — sub-agents ONLY.** Investigation,
-  grep-and-collect, file maps, lint runs, mechanical tasks. This is the floor for
-  a *sub-agent*, NOT for an implementer or a reviewer.
-- **`model: "sonnet"` @ MEDIUM effort — implementers, verifiers, reviewers.**
-  Not low. A reviewer on low effort is a rubber stamp with extra steps, and
-  rubber-stamped reviews are how a merge gate that ran zero tests survived six
-  sessions.
-- **`model: "opus"` @ low — orchestrators.** Not selectable for sub-agents —
-  set by the operator on the agent's runtime-config.
-- **`model: "opus"` — NOT your call.** Allowed only when (a) the operator
-  explicitly asked for a deep review or prose review in this task, or (b) a
-  skill you are running prescribes Opus for the specific step you are currently
-  executing — NOT for every spawn under that skill. "This research is hard /
-  important" is NOT a justification — hard investigation is exactly what Sonnet
-  is for.
+These are the three tiers, with their Claude-runtime resolution shown as a
+worked example — **if you are running under a different runtime, resolve the
+same tier from your own runtime's preset (`RuntimePreset.TierModels`) or
+`runtime.role_models`, not from the Claude column:**
+
+| Role | Tier | Resolved for Claude (example) |
+| ---------------------------- | ------------- | ------------------- |
+| **Orchestrator / coordinator** | `orchestration` | **`opus` / low** |
+| **Implementer** | `judgment` | **`sonnet` / medium** |
+| **Verifier / reviewer** | `judgment` | **`sonnet` / medium** |
+| **Sub-agent** (investigation, grep, mechanical) | `mechanical` | **`sonnet` / low** |
+
+- **`mechanical` tier (sub-agents ONLY)** — investigation, grep-and-collect,
+  file maps, lint runs, mechanical tasks. Read the effective model and effort
+  at use from `runtime.role_models`. For other runtimes, use their own
+  mechanical-tier value (`RuntimePreset.TierModels`), not a Claude name.
+  The mechanical tier is for sub-agents only, never for an implementer or a reviewer.
+- **`judgment` tier (implementers, verifiers, reviewers)** — resolves to
+  `sonnet` @ MEDIUM effort on Claude. Not low. A reviewer on low effort is a
+  rubber stamp with extra steps, and rubber-stamped reviews are how a merge
+  gate that ran zero tests survived six sessions.
+- **`orchestration` tier (orchestrators/coordinators)** — resolves to `opus` @
+  low on Claude. Not selectable for sub-agents — set by the operator on the
+  agent's runtime-config.
+- **`orchestration` tier is NOT your call to spawn.** Allowed only when (a) the
+  operator explicitly asked for a deep review or prose review in this task, or
+  (b) a skill you are running prescribes the orchestration tier for the
+  specific step you are currently executing — NOT for every spawn under that
+  skill. "This research is hard / important" is NOT a justification — hard
+  investigation is exactly what the `judgment` tier is for.
 
 ## Worked examples — LITERAL ARGUMENTS, AND EFFORT IS TOOL-DEPENDENT
 
-**Pin `model` on every spawn. Pass `effort` wherever the mechanism exposes it.**
-Syntax per mechanism — re-check the schema in front of you rather than restating
-from memory, because it can change:
+**Pin `model` on every spawn, using the value your runtime's own preset
+(`RuntimePreset.TierModels`) or `runtime.role_models` resolves the tier to.**
+**Pass
+`effort` wherever the mechanism exposes it** — some mechanisms don't. Syntax per
+mechanism — re-check the schema in front of you rather than restating from
+memory, because it can change:
 
 | Mechanism | `model` | `effort` |
 |---|---|---|
@@ -76,8 +102,14 @@ from memory, because it can change:
 | **Workflow `agent()`** (opts: label, phase, schema, model, effort, isolation, agentType) | ✅ settable | ✅ settable |
 | **Agent DEFINITION** (`.claude/agents/*.md` / plugin `agents/*.md` frontmatter) | ✅ | ✅ — sets the default for that agent type |
 | **`thrum tmux create` / `launch`** | ✅ `--model` | ✅ `--effort` — pass on BOTH |
+| **Other runtimes' own spawn mechanism** | ✅ settable | runtime-dependent — check its own schema |
 
-**Agent tool — `model` only. It takes no `effort` argument.**
+**Below is ONE fully concrete example — what a `judgment`-tier spawn looks
+like once resolved for Claude's own Agent tool (which takes no `effort`
+argument).** It is Claude-specific syntax with a Claude-specific model string;
+if you are running under a different runtime, use that runtime's own spawn
+mechanism and its own resolved model+effort from `RuntimePreset.TierModels` /
+`runtime.role_models` instead of copying this literal string.
 
 ```python
 Agent(subagent_type="general-purpose", model="sonnet",
@@ -85,12 +117,14 @@ Agent(subagent_type="general-purpose", model="sonnet",
       prompt="...")
 ```
 
-**The tier philosophy still governs even where the Agent tool cannot express it:**
-sonnet-low for investigation and mechanical work, sonnet-medium for reviewers,
-verifiers and implementers. Where effort is not settable, carry the intent through
-the agent definition, the Workflow opts, or the tmux launch flags.
+**The tier philosophy still governs even where a mechanism cannot express
+`effort`:** the `model` value alone still must be the tier's resolved value for
+YOUR runtime — never a bare Claude name assumed universal. Where effort is not
+settable, carry the intent through the agent definition, the Workflow opts, or
+the tmux launch flags instead.
 
-An agent definition can also carry a default:
+An agent definition can also carry a default (Claude example — resolve to
+your own runtime's `mechanical`-tier value if you are not Claude):
 
 ```yaml
 # claude-plugin/agents/message-listener.md
@@ -99,53 +133,87 @@ model: sonnet
 effort: low
 ```
 
-**Workflow `agent()` — effort IS a literal argument. Pass it.**
+**Workflow `agent()` — effort IS a literal argument. Pass it, resolved for
+your runtime's tier:**
 
 ```javascript
-agent(prompt, { model: "sonnet", effort: "medium" })          // reviewer / implementer
-agent(prompt, { model: "sonnet", effort: "low" })             // mechanical sub-agent
+agent(prompt, { model, effort })   // `model`/`effort` = your runtime's resolution
+                                    // of the `judgment` tier (reviewer/implementer)
+                                    // or the `mechanical` tier (sub-agent) —
+                                    // resolve via RuntimePreset.TierModels /
+                                    // runtime.role_models for the literal values
 ```
 
-**THE DIRECTIVE, imperative and not a comment: REVIEWERS RUN SONNET AT MEDIUM
-EFFORT.** Pass `effort: "medium"` literally under Workflow, in the agent
-definition, or on `thrum tmux create`/`launch`. Never dispatch a reviewer "from
-memory".
+**THE DIRECTIVE, imperative and not a comment: REVIEWERS RUN THE `judgment`
+TIER, WHICH IS MEDIUM EFFORT ON EVERY RUNTIME THAT HAS AN EFFORT KNOB.** Pass
+the resolved effort literally under Workflow, in the agent definition, or on
+`thrum tmux create`/`launch` (the Agent tool takes no `effort`, so `model`
+alone must still be the `judgment`-tier value there). Never dispatch a
+reviewer "from memory", and never dispatch one at the mechanical tier.
 
 **AND VERIFY, DO NOT ASSERT:** any claim about what a tool does or does not expose
 must be checked against the schema in front of you.
 
-Never select Opus or Haiku on own judgment — use Sonnet, at the floor of
-sonnet-low.
+Never select the `orchestration` tier on your own judgment — use the
+`judgment` tier's configured value from `runtime.role_models`.
+
+## Where the tier-model mapping lives
+
+**Do not copy a tier's model string from this doc — read it at the moment of
+use.** The three semantic tiers (`mechanical` / `judgment` / `orchestration`)
+are the same across every runtime; only the concrete model+effort differs per
+runtime, and that mapping lives in exactly two places:
+
+- **The runtime's own preset** (the `TierModels` field of the runtime preset
+  schema) — the machine-checked, per-runtime tier→model
+  table. A runtime with no entry for a tier has no fleet-configured value for
+  it and resolves to nothing rather than inheriting another runtime's model.
+- **`runtime.role_models` in `.thrum/config.json`** — operator configuration
+  for this project, which always outranks the preset's tier table.
 
-## Fleet model-tiering by runtime/role
+**If you are running under Claude**, use the Agent tiers table above
+(orchestrator/implementer/reviewer/sub-agent → orchestration/judgment/
+judgment/mechanical), plus brainstormer → `orchestration` and brainstormer's
+own subagents → `mechanical` (except reviewers, which are always `judgment`).
 
-Different runtimes and roles pin different tiers. Claude tiers are canonical —
-see the Agent tiers table above (orchestrator/implementer/reviewer/sub-agent),
-plus brainstormer → opus-medium and brainstormer's own subagents → sonnet-low
-(except reviewers → sonnet-medium). Other runtimes:
+**If you are running under a different runtime, read your own tier's value
+from the two sources above** — never assume Claude's model names apply, and
+never hard-code a model string you saw once in a doc or a prior session.
 
-| Runtime      | Role                         | Model / effort                                      |
-| ------------ | ---------------------------- | --------------------------------------------------- |
-| OpenCode     | default                      | GLM-5.2 (fine as-is)                                |
-| Codex        | orchestrator / reviewer      | gpt-5.5-medium                                      |
-| Codex        | implementer                  | gpt-5.5-low                                         |
-| Cursor-agent | default                      | composer-2.5 (fine as-is)                           |
+A runtime/role pair with no fleet-configured tier value has no override —
+resolve it to that runtime's own configured default, and pass it explicitly
+(never leave it unset — see "Never let an unresolved pin fall through"
+below).
 
 ## Pin every spawn explicitly — the floor depends on the ROLE, not the depth
 
-Every orchestrator MUST pass an explicit `model:` on EVERY subagent it spawns, and
-`effort` wherever the mechanism exposes it. An unspecified subagent SILENTLY
-INHERITS THE PARENT'S MODEL — so an Opus orchestrator that forgets the pin just
-spent Opus tokens on a grep.
+Every orchestrator MUST pass an explicit `model:` on EVERY subagent it spawns,
+resolved for its own runtime, and `effort` wherever the mechanism exposes it.
+An unspecified subagent SILENTLY INHERITS THE PARENT'S MODEL — so an
+orchestration-tier orchestrator that forgets the pin just spent its
+(expensive) tier's tokens on a grep.
 
 **The floor is set by what the agent DOES, not by how deep it sits** — see the
 Agent tiers table above. This applies recursively: an implementer spawning its
 own helpers pins them by THEIR role, not by copying its own tier down.
 
 The check before every spawn: what is this agent's ROLE? Reviewer or implementer?
-sonnet-medium. Pure investigation or mechanical work? sonnet-low. Never leave it
+`judgment` tier. Pure investigation or mechanical work? `mechanical` tier. Then
+resolve that tier to your runtime's concrete model+effort. Never leave it
 unspecified.
 
+### Never let an unresolved pin fall through
+
+**An unsupported or unrecognized model name must never block delegation, and
+must never cause silent inheritance of the parent's model.** If your
+runtime's preset has no `TierModels` entry for this tier, or a resolved name
+is rejected by the runtime you're spawning under, do NOT skip the pin and do
+NOT let the spawn go unpinned so it falls back to inheriting the caller's
+model — fall back explicitly to the runtime's own configured default for the
+matching tier and pass THAT, so every spawn is always pinned to some resolved
+model+effort. An unset `model:` is a bug at every layer of this stack, not
+just under Claude.
+
 ## Paste the constraint block into the child prompt — the pin is not enough
 
 **A model pin is an ARGUMENT and travels by itself. A behavioural constraint is
@@ -162,8 +230,10 @@ that stops at depth 1 is absent where the work happens.
   tool's own guidance suggests it. It trips a permission modal, and A FROZEN
   PANE EMITS NOTHING, so nobody can tell you are blocked. If you must background
   work, wait for the completion notification.
-- Every sub-agent YOU spawn gets an explicit `model:` — sonnet (low mechanical,
-  medium judgment). HAIKU IS BANNED. Opus is never yours.
+- Every sub-agent YOU spawn gets an explicit `model:`, resolved for your
+  runtime's tier — `mechanical` (rote/find-replace) or `judgment` (real
+  analysis). Read the effective model and effort from `runtime.role_models` at
+  use. The `orchestration` tier is never yours to spawn.
 - READ-ONLY git outside your own worktree. NEVER `checkout`/`reset`/`restore`/
   `stash`/`clean` in ANY directory — `stash` is one shared stack across all
   worktrees and the shared tree holds live agents' uncommitted state.
@@ -175,15 +245,22 @@ signal this condition produces.
 
 ### Cheap subagents → fan out, don't pile up
 
-Because sonnet-low subagents are cheap, prefer MANY small parallel subagents
-over one subagent handed a pile of tasks. When a research or investigation task
-has independent parts, partition it and dispatch the parts in parallel (use the
+Because Haiku 5.5 supports summarization and mechanical sub-agent work, prefer
+MANY small parallel subagents over one agent handed a pile of tasks. Read the
+effective model and effort from `runtime.role_models` at dispatch. When research or
+investigation has independent parts, partition them in parallel (use the
 `efficient-multi-agent-research` skill) — smaller scopes are cheaper, run
 concurrently (faster), and keep each subagent's context tight. One subagent
 given ten tasks is the anti-pattern.
 
 ## ⚠️ The pin-verification command LIES — do not trust it
 
+**This section's examples are Claude-specific** (`thrum tmux capture`'s footer
+format, and the historical Sonnet/Opus incident it documents) because that is
+where this defect was measured — but the underlying rule generalizes: verify
+a pin by reading the runtime's own RESOLVED status output, never a stored
+"configured" value, whichever runtime you're on.
+
 `thrum agent runtime-config get <agent>` reports the **configured** value, not the
 **resolved** one.
 
@@ -264,3 +341,35 @@ launch **by construction**.
 An implementer pinned to sonnet, with an implementer role-default of sonnet, comes up
 correct whether or not the pin landed — so "pin sonnet, confirm sonnet" passes whether
 or not the fix works.
+
+## Paste blocks for child prompts
+
+Paste these verbatim into a child prompt when the work involves the named activity.
+
+--- SUB-AGENT HYGIENE ---
+- No kill -0, Monitor or until-loop polling.
+- No pgrep -f.
+- Kill only by a captured PID number.
+- Use rm -r, never rm -rf; a variable path uses "${d:?}".
+- No 2>/dev/null on destructive commands.
+- Bounded timeouts on everything.
+- Remove only the worktree you created in this task, by its recorded path, never with --force.
+- Never demonstrate an unguarded destructive idiom, even on a literal path.
+--- END SUB-AGENT HYGIENE ---
+
+--- TESTS ---
+- To prove a selector resolves, use `go test <pkg> -list '<selector>'` plus a `-list '^TestNoSuchThingAtAll$'` negative control that must list zero tests. Never `-run '<sel>' -list '.*'`.
+- `bd list -l` is --label; use `-n` for a limit.
+- A timeout with 0 FAIL is neither red nor green: classify it as a bound failure, read the panic's "running tests:" line, and re-run wider.
+--- END TESTS ---
+
+--- WORKTREE TEARDOWN & SALVAGE ---
+- Before any teardown, enumerate with both flags: `git -C <wt> status --porcelain --untracked-files=all --ignored -- .thrum`.
+- Salvage anything found to a durable path (not /tmp), one subdirectory per worktree, filenames path-flattened.
+- Never glob `.thrum/context/*.md`; salvage the exact agent-name file only, and assert no `project_state.md` landed in any salvage output.
+- Verify salvage by name set first, then `cmp` each file, with a negative control proving `cmp` detects a difference.
+- Kill the tmux session first (`thrum tmux kill <session>`), verify it is gone, then plain `git worktree remove`, never `--force`.
+- Afterwards verify by effect: gone from `git worktree list` and from disk, and every remaining live pane's cwd still resolves (`tmux list-panes -a -F '#{pane_current_path}'`, then `git rev-parse --show-toplevel` per pane).
+- Build the in-use protection set from live pane cwds, not from a name or registry list.
+- Report the removal count and the registry delta separately.
+--- END WORKTREE TEARDOWN & SALVAGE ---

package/assets/skills/closing-findings-while-warm/SKILL.md

@@ -94,8 +94,7 @@ tool that can prove it, not by trusting the sentence that claims it.
 
 ## Project-specific rules (already loaded)
 
-Read the shared partial at the absolute path:
-`claude-plugin/commands/_project-rules-protocol.md`
+Load the /thrum:project-rules-protocol skill and follow it.
 
 If you accumulate a new rule mid-session (the user corrects you), capture it
 via the `implementer-maintaining-memory` skill (or `coordinator-maintaining-

package/assets/skills/configure-roles/SKILL.md

@@ -155,7 +155,7 @@ For each role:
    - If beads detected: include `bd` commands in Task Tracking section
    - If MCP servers detected: add to Efficiency section
    - If specific skills detected: reference them
-   - If worktree restrictions: adjust Scope Boundaries
+   - If worktree restrictions: adjust the Scope section
 
 3. Write to `.thrum/role_templates/{role}.md`. Keep per-agent template tokens
    (`{{.AgentName}}`, `{{.Module}}`, `{{.WorktreePath}}`,
@@ -226,4 +226,4 @@ rendered files from saved answers without asking any questions.
 | Thrum MCP server     | Add MCP tool references, CLI fallback for sub-agents     |
 | Claude plugin skills | List installed skills with usage guidance                |
 | Context7 MCP         | Add library docs guidance to Efficiency section          |
-| Multiple worktrees   | Add worktree scope rules to Scope Boundaries             |
+| Multiple worktrees   | Add worktree scope rules to the Scope section            |

package/assets/skills/coordinator-assessing-agent-completion/SKILL.md

@@ -176,11 +176,10 @@ salvaged files distinct names and land the salvage somewhere durable (the main r
 
 ## 🔴 The reap is worktree-removal-only — and TEST every step on ONE item first
 
-**`thrum agent delete --force` is REFUSED by the CAS guard on a stale agent with an empty
-`agent_pid_start_time`** (*"expected-state premise is required … refusing rather than treating
-an empty/never-read premise as a match"*). `--force` does NOT bypass it; the guard is
-correct. So the reap that actually frees load is worktree removal — but salvage BEFORE you remove,
-then remove PLAIN (no `--force`):
+**`thrum agent delete` refuses an agent whose linked worktree still exists** (and any agent
+with a live pid/tmux process, and coordinators); `--force` does NOT bypass these guards. So
+the reap that frees load is worktree removal first — salvage BEFORE you remove, then remove
+PLAIN (no `--force`), then `thrum agent delete`:
 
 1. Enumerate untracked+ignored `.thrum` content — BOTH flags, one flag alone misses a class:
    `git status --untracked-files=all --ignored -- .thrum`
@@ -200,9 +199,10 @@ then remove PLAIN (no `--force`):
    mistake it for protecting the ignored-file class. (Not a pipe — a pipe returns the last
    command's rc, not `git`'s.)
 
-The delete (`thrum agent delete`) best-effort-fails and leaves a **benign orphan DB row**,
-which you LEAVE (filtered at query per the fleet ruling; never `agent cleanup --force` to
-tidy them).
+Then REAP the agent row with `thrum agent delete <agent>` once the worktree is gone and no
+process is live: orphan rows must be reaped, not left. Never use `thrum agent cleanup
+--force` (it can flag live fleet agents). A refused reap on a dead, worktree-less agent is a
+bug: report it, do not route around it.
 
 ⚠️ **After a large reap you may see a `DeadAgentSweeper` skip alert + elevated write-RPC
 latency — do NOT assume the reap caused it.** This box carries a standing single-writer
@@ -302,8 +302,9 @@ RSS-MB.
   list AND disk), not just the exit code.
 - **Rank candidates by last-message CONTENT, not elapsed time** — your own
   broadcasts reset every recipient's idle clock.
-- **`--force` on agent-delete does NOT bypass the CAS guard** on a stale agent — the
-  reap that frees load is worktree removal, not the delete.
+- **`--force` on agent-delete does NOT bypass its guards** — the worktree must go first
+  (teardown with salvage or plain `git worktree remove`), then `thrum agent delete` reaps
+  the row.
 - **Reap order is `thrum tmux kill <session>` FIRST, THEN `git worktree remove`** —
   removing the worktree alone leaves the agent's tmux session alive with a
   now-deleted cwd, which the fleet flags as recurring "cwd drift" and whose runtime

package/assets/skills/coordinator-branch-split-on-block/SKILL.md

@@ -159,8 +159,7 @@ asserted after the fact).
 
 ## Project-specific rules (already loaded)
 
-Read the shared partial at the absolute path:
-`claude-plugin/commands/_project-rules-protocol.md`
+Load the /thrum:project-rules-protocol skill and follow it.
 
 If you accumulate a new rule mid-session about branch-splitting, capture it
 via the `coordinator-maintaining-memory` skill — it references the

package/assets/skills/coordinator-context-monitoring/SKILL.md

@@ -30,13 +30,13 @@ What's forbidden is a script that bypasses this skill and fires
 
 This skill's tier ladder (Steps 3–5) governs how the coordinator restarts
 **other** agents. When the **coordinator restarts ITSELF**, a different rule
-applies and it is absolute — but D5 (owner-ruled)
+applies and it is absolute — but the current ruling
 REVERSES which command that is:
 
 > **The coordinator ALWAYS uses the EXTENDED snapshot grade for itself — never
 > the standard/compact form. Which command carries that grade is
 > runtime-directed: `/thrum:compact-extended` on any runtime with a verified
-> compact-equivalent skill (D6, the default), `/thrum:restart-extended` ONLY
+> compact-equivalent skill (the default), `/thrum:restart-extended` ONLY
 > as the fallback on a runtime without one (today: muse, copilot).**
 
 This is a REVERSAL of the prior absolute rule ("ALWAYS restart-extended, NEVER
@@ -62,7 +62,7 @@ Practical trigger points for coordinator self-restart/compact:
 In every one of these: run `/thrum:compact-extended` if the coordinator's
 runtime has a compact equivalent (the default); `/thrum:restart-extended` only
 if it does not. (The role-rule `coord-always-restart-extended` — `Coordinator
-ALWAYS uses /thrum:restart-extended` — is RETIRED as of D5; see
+ALWAYS uses /thrum:restart-extended` — is RETIRED; see
 `thrum memory` for its retirement record. This skill is the always-loaded home
 so the CURRENT rule survives even when memory isn't consulted.)
 
@@ -163,7 +163,7 @@ is a single monitor for all lenses in v1, not one per lens.
 | `idle_mid_task`             | ON      | L2 — 30-min idle-with-open-task detection (bead cross-ref). RECOMMEND `/thrum:sleep-extended`; a no-task variant REPORTs `idle-no-task` at lower priority.        |
 | `snapshot_awaiting_restart` | ON      | L3 — pane text + fresh-snapshot two-signal heuristic. RECOMMEND `thrum tmux restart <agent>` (never autonomous).                                                  |
 | `blocked_on_human_modal`    | ON      | L4 — detects spend-limit/permission/consent modal prompts. DETECTION ONLY, never auto-answers; routes into the L5 ledger.                                         |
-| `pending_human_ledger`      | ON      | L5 — flat JSONL ledger of items awaiting a human. EXEMPT from D5 backoff — surfaces every tick. `hb_ledger_resolve` (the resolution path) is defined but has zero call sites — nothing marks an entry resolved, so the ledger is append-only-forever, not "until resolved." |
+| `pending_human_ledger`      | ON      | L5 — flat JSONL ledger of items awaiting a human. EXEMPT from progressive backoff — surfaces every tick. `hb_ledger_resolve` (the resolution path) is defined but has zero call sites — nothing marks an entry resolved, so the ledger is append-only-forever, not "until resolved." |
 | `waiting_on_coord`          | ON      | L9 — 21-rule pattern match (folded in from the standalone waiting-on-coord sweep) + warm-hold exemption. RECOMMEND coordinator answer.                            |
 
 ### Default-OFF lenses (E8, flag-gated — NOT YET IMPLEMENTED as of E7)
@@ -183,8 +183,7 @@ produce no output until enabled.
 ## Configuration
 
 The heartbeat system is configured under the `heartbeat` key in
-`.thrum/config.json` (Go type: `HeartbeatConfig` in
-`internal/config/heartbeat.go`). Example:
+`.thrum/config.json` (Go type: `HeartbeatConfig`). Example:
 
 ```json
 {
@@ -222,10 +221,10 @@ The heartbeat system is configured under the `heartbeat` key in
 | -------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `cadence_minutes_day`                                    | Daytime cadence target (default 30 min). The underlying monitor runs `@every 30m` and self-gates so only busy-fleet daytime ticks fire.                                |
 | `cadence_minutes_overnight`                              | Overnight cadence target (default 60 min). The monitor fires every other `@every 30m` tick overnight (effective 60-min rate).                                          |
-| `busy_only_daytime`                                      | When `true`, daytime ticks are skipped unless any agent has `agent_status=working` (D3 busy-signal gate).                                                              |
+| `busy_only_daytime`                                      | When `true`, daytime ticks are skipped unless any agent has `agent_status=working` (busy-signal gate).                                                              |
 | `busy_signal`                                            | Algorithm for "is the fleet busy?" Default `working_or_activity_30m`: any agent working OR activity in the last 30 min.                                                |
 | `overnight_window.tz`                                    | **MUST be an explicit IANA timezone** (e.g. `"America/New_York"`). If unset, the sweep warns and falls back to always-daytime-rate rather than silently guessing. |
-| `backoff.start_after`                                    | Number of consecutive unchanged detections of the same problem before D5 progressive backoff begins.                                                                   |
+| `backoff.start_after`                                    | Number of consecutive unchanged detections of the same problem before progressive backoff begins.                                                                   |
 | `backoff.multiplier`                                     | Each backoff step multiplies the surface interval by this factor (default 2×).                                                                                         |
 | `backoff.floor_every`                                    | The surface interval is capped at this many ticks — the problem is never fully silenced (always surfaces at least once per `floor_every` ticks).                       |
 | `lenses.<name>.enabled`                                  | Enable/disable a lens individually.                                                                                                                                    |
@@ -238,8 +237,8 @@ The heartbeat system is configured under the `heartbeat` key in
 `.thrum/config.json`** to configure the heartbeat. Two gotchas make this
 non-obvious; both bite silently.
 
-**1. All-or-nothing merge (the sharp footgun).** The loader
-(`internal/config/daemon.go`, `LoadThrumConfig`) applies
+**1. All-or-nothing merge (the sharp footgun).** The config
+loader (`LoadThrumConfig`) applies
 `DefaultHeartbeatConfig()` **only when the stanza is effectively absent**
 (`schema_version == 0` AND zero lenses):
 
@@ -254,7 +253,7 @@ There is **no field-level deep merge.** The moment you write a stanza with
 `cadence_minutes_day: 0`, `enabled: false`, and **all 12 lenses disabled**. So
 "I'll just set the timezone" with a three-line stanza silently turns the whole
 sweep off. **Always write the COMPLETE stanza** — copy
-`DefaultHeartbeatConfig()` (`internal/config/heartbeat.go`) in full, then change
+`DefaultHeartbeatConfig()` in full, then change
 only what you need.
 
 **2. `overnight_window.tz` MUST be an explicit IANA zone.** Default is `""` (the
@@ -332,7 +331,7 @@ repeals fix-while-warm.
   restart is **under one turn** once context is meaningfully above the re-prime
   floor.
 - **Orchestrators re-prime far cheaper than coordinators, and it is structural:**
-  `internal/cli/prime_filter.go` gives ONLY `role=="coordinator"` the full
+  the prime output filter gives ONLY `role=="coordinator"` the full
   project-state passthrough. Measured orchestrator re-prime ≈ 30k tokens.
 - Coordinators keep the ladder below for a stated reason — larger re-entry cost,
   plus decision-dense context a snapshot cannot faithfully reconstruct.

package/assets/skills/coordinator-deploying-a-node/SKILL.md

@@ -48,7 +48,9 @@ If the project has no WAL/SHM, this section is N/A — skip and note.
 
 ## 4. Never wrap service start/restart in a blind timeout
 
-Run the project's service restart command (`fleet.deployment.thrum.service.restart_command` or product equivalent) without a blind timeout wrapper. A timeout that kills a migrating restart mid-migration manufactures a half-migrated store.
+🔴 **On macOS, the restart command is NOT `service.restart_command` — it is `service.mac_restart_command`** (Thrum: `scripts/mac-daemon-restart-via-cron.sh`, run from inside the repo). A daemon restarted from a terminal or agent pane gets its Local Network (TCC) permission attributed to that terminal and is silently denied LAN peer dials (`no route to host`): peers go dark while the node itself looks healthy, and `PPID 1` does NOT prove it was re-parented correctly. Check the node's OS before choosing the command; this has been forgotten on primary repeatedly. After a mac restart, verify the peers on the LAN reconnect, not just the version.
+
+Run the project's service restart command (`fleet.deployment.thrum.service.restart_command`, or `service.mac_restart_command` on macOS, or product equivalent) without a blind timeout wrapper. A timeout that kills a migrating restart mid-migration manufactures a half-migrated store.
 
 - Adapter flag `service.never_timeout` is true.
 - Signal-window rules are adapter data: `migration.signal_rules` (`SIGQUIT` fatal-always, `SIGUSR1` fatal-before-socket). Respect them — do not send fatal signals in the forbidden window.

package/assets/skills/coordinator-dispatching-work/SKILL.md

@@ -26,7 +26,9 @@ send. See `coordinator-managing-state-and-lifecycle` § "Destroy an agent before
 tearing down its worktree" for the canonical sequence (`thrum tmux kill` BEFORE
 `thrum worktree teardown`). The dispatching skill mentions it here so you find
 the cross-reference when planning a wave recycle, not just when reading the
-lifecycle skill end-to-end.
+lifecycle skill end-to-end. Teardown does not delete the agent row: it stays
+retired until a separate `thrum agent delete <agent>` (after the worktree is
+gone) or the sweeper reaps it.
 
 ## Never spawn sub-agents into worktrees where Thrum agents are running
 
@@ -307,14 +309,13 @@ EOF
 ### Step 3: Your role during execution
 
 - You receive the orchestrator's merge report when all epics complete.
-- Run your merge-approval gate (see Merge Approval Gate in your preamble).
+- Run your merge-approval gate (see the merge approval rules in your preamble).
 - Monitor the orchestrator's status updates; escalate to the operator only for
   genuine judgment calls (architectural pivot, scope change, budget concern).
 
 ## Project-specific rules (already loaded)
 
-Read the shared partial at the absolute path:
-`claude-plugin/commands/_project-rules-protocol.md`
+Load the /thrum:project-rules-protocol skill and follow it.
 
 If you accumulate a new rule mid-session (the user corrects you), capture it via
 the `coordinator-maintaining-memory` skill — it references the