opencode-thrum-pro 0.1.5 → 0.1.7

package/assets/skills/project-setup/resources/implementation-agent.md

@@ -35,9 +35,13 @@ When filling this template to create an implementation prompt:
 - `{{WORKTREE_PATH}}` — Absolute path to the working worktree
 - `{{BRANCH_NAME}}` — Git branch for this work (e.g., `feature/auth`)
 - `{{BASE_BRANCH}}` — The branch this work merges into. **Resolve it from the
-  project's actual merge target** (`jq -r '.orchestration.merge_target'
-  .thrum/config.json`); do not assume `main` and do not carry a branch name
-  from another document
+  project's actual merge target**
+  (`CONFIG=.thrum/config.json;
+  [ -f .thrum/redirect ] && CONFIG="$(cat .thrum/redirect)/config.json";
+  jq -r '.orchestration.merge_target' "$CONFIG"`
+  — a worktree's `.thrum/` holds only a `redirect` file, not its own
+  `config.json`); do not assume `main` and do not carry a branch name from
+  another document
 - `{{DESIGN_DOC}}` — **Absolute path** to the design spec (if applicable)
 - `{{REFERENCE_CODE}}` — Paths to reference implementations (if any)
 - `{{QUALITY_COMMANDS}}` — Commands for test/lint, **scoped to packages this
@@ -88,12 +92,12 @@ Otherwise, orchestrate via the agent table below.
 
 | Dispatch                       | Agent type                     | Model                                   | Background? |
 | ------------------------------ | ------------------------------ | --------------------------------------- | ----------- |
-| Research / explore a code area | `Explore` or `general-purpose` | `sonnet`                                | yes         |
-| Implement a task               | `general-purpose`              | `sonnet` (low effort if purely mechanical) | no       |
-| Verify a task against the plan | `general-purpose`              | `sonnet`                                | no          |
-| Run tests / lint               | `general-purpose`              | `sonnet` (low effort)                   | yes         |
+| Research / explore a code area | `Explore` or `general-purpose` | per `choosing-subagent-models`          | yes         |
+| Implement a task               | `general-purpose`              | per `choosing-subagent-models` (low effort if purely mechanical) | no |
+| Verify a task against the plan | `general-purpose`              | per `choosing-subagent-models`          | no          |
+| Run tests / lint               | `general-purpose`              | per `choosing-subagent-models` (low effort) | yes     |
 
-Always pass `model:` explicitly — never let a sub-agent inherit your (Opus)
+Always pass `model:` explicitly — never let a sub-agent inherit your own
 model. Label every dispatch's `description` with `research:` / `implement:` /
 `verify:` (the evaluation harness classifies delegation shape from these
 labels).
@@ -115,7 +119,7 @@ labels).
 
 ### Verifier dispatch (per task)
 
-After an implementation dispatch returns, spawn a `sonnet` verifier against the
+After an implementation dispatch returns, spawn a verifier sub-agent (model per `choosing-subagent-models`) against the
 plan the implementing sub-agent was given — confirm the diff meets the
 acceptance criteria. This is the in-loop check; the full code review still
 happens at Phase 3: Self-Review Gate.
@@ -131,7 +135,7 @@ section.
 cd {{WORKTREE_PATH}}
 thrum quickstart --name {{AGENT_NAME}} --role implementer --module {{BRANCH_NAME}} --intent "Implementing {{EPIC_ID}}"
 thrum inbox --unread
-# Tip: thrum inbox --unread peeks without marking read; thrum message read --all to mark all read
+# Tip: thrum inbox --unread peeks without marking read; thrum message read --all --force to mark all unread (run `--all` alone first — dry run)
 # Tip: default page is 10 newest-first — stale unread sorts LAST; use `thrum message search "<term>"` to find it
 thrum send --to @{{SUPERVISOR_NAME}} --stdin <<'EOF'
 Starting work on {{EPIC_ID}}
@@ -177,11 +181,13 @@ EOF
 Whether starting fresh or resuming after context loss, always begin here. This
 phase is idempotent — running it multiple times is safe and expected.
 
-🔴 **BEFORE ANYTHING ELSE — OBTAIN THE PLAN INTO YOUR WORKTREE AND CONFIRM YOU CAN OPEN IT.** Do NOT implement from plan detail relayed to you in messages or beads — relay is lossy and drifts as the plan is updated.
+🔴 **BEFORE ANYTHING ELSE — OBTAIN THE PLAN INTO YOUR WORKTREE AND CONFIRM YOU CAN OPEN IT.**
+Do NOT implement from plan detail relayed to you in messages or beads — relay is lossy and drifts as the
+plan is updated.
 
 ```bash
 cd {{WORKTREE_PATH}}
-git pull                 # pull the committed plan into this worktree
+git pull --no-rebase     # pull the committed plan into this worktree (merge; a bare pull aborts on divergence)
 head -1 {{PLAN_FILE}}    # confirm the plan file actually opens here
 ```
 
@@ -216,7 +222,7 @@ git status
 git --no-pager log --oneline -10
 
 # Pull latest changes (if remote tracking is set up) — merge, never rebase
-git pull
+git pull --no-rebase
 ```
 
 ### Step 3: Explore Existing Code
@@ -432,35 +438,40 @@ bd list --type=epic | grep -i refactor
 
 If no refactoring epic exists, create one:
 
-`--description` is multi-line prose — never double-quoted inline. On
-`scripts/bd-shared`, `--stdin`/`--body-file` are refused (remote-path
-resolution + silent-empty-body hazards), so write it to a scratch file and
-pass `-d "$(cat <file>)"`; see your role preamble's 🔴 PROSE INTO A COMMAND
-rule.
+`--description` is multi-line prose — never double-quoted inline. Write it to a
+scratch file and pass `--body-file <file>`; see the heredoc-or-file rule in your role preamble. `scripts/bd-shared` delivers `--body-file` (and `--stdin`)
+content: it reads the file on YOUR box and pipes those bytes to bd, and an empty
+or blank body is refused loudly. Only `-f`/`--file` and `--graph` (bulk-plan
+files) are refused there. Scratch files go in `/private/tmp` on macOS, where
+`/tmp` is a symlink (check `[ -L /tmp ]`), and in `/tmp` elsewhere.
 
 ```bash
-cat > /tmp/refactor-epic-desc.md <<'EOF'
+# Scratch dir: /private/tmp on macOS (where /tmp is a symlink), /tmp elsewhere.
+SCRATCH=$([ -L /tmp ] && echo /private/tmp || echo /tmp)
+cat > "$SCRATCH/refactor-epic-desc.md" <<'EOF'
 Persistent backlog for refactoring, DRY improvements, and code organization
 opportunities discovered during feature work. Tasks are added by
 implementation agents as they encounter opportunities. Reviewed and
 prioritized by the coordinator periodically.
 EOF
-bd create --title="Refactoring & DRY Opportunities" --type=epic --priority=3 -d "$(cat /tmp/refactor-epic-desc.md)"
+bd create --title="Refactoring & DRY Opportunities" --type=epic --priority=3 --body-file "$SCRATCH/refactor-epic-desc.md"
 ```
 
 #### 2. Log the Opportunity
 
-Same `--description` handling as §1 above (scratch file + `-d "$(cat <file>)"`).
+Same `--description` handling as §1 above (scratch file + `--body-file`).
 
 ```bash
-cat > /tmp/refactor-task-desc.md <<'EOF'
+# Scratch dir: /private/tmp on macOS (where /tmp is a symlink), /tmp elsewhere.
+SCRATCH=$([ -L /tmp ] && echo /private/tmp || echo /tmp)
+cat > "$SCRATCH/refactor-task-desc.md" <<'EOF'
 **Discovered during:** {{EPIC_ID}}
 **Files:** <file paths>
 **Opportunity:** <what could be improved — duplicated code, hardcoded values, missed abstraction>
 **Suggested approach:** <how to fix it>
 **Effort estimate:** small/medium/large
 EOF
-bd create --title="Refactor: <short description>" --type=task --parent=<refactoring-epic-id> --priority=3 -d "$(cat /tmp/refactor-task-desc.md)"
+bd create --title="Refactor: <short description>" --type=task --parent=<refactoring-epic-id> --priority=3 --body-file "$SCRATCH/refactor-task-desc.md"
 ```
 
 #### 3. Continue With Your Assigned Work
@@ -494,11 +505,13 @@ If a task is blocked:
 
 ```bash
 # Ask the blocking agent for help
-# NOTE: --mention @implementer (with no --to) delivers ONLY to agent(s) matching
-# that role/name — it does not go to the supervisor and does not broadcast. A
-# message with ZERO addressing (no --to, no mentions) routes to the local
-# coordinator instead. Broadcast to everyone requires an explicit
-# --to everyone / --mention @everyone.
+# NOTE: --mention @implementer (with no --to) only delivers if "implementer"
+# is itself a registered agent ID — mentions resolve exact agent IDs only, no
+# role fan-out (P0 ruling: removed by design, do not
+# restore). A message with ZERO addressing (no --to, no mentions) routes to
+# the local coordinator instead. There is no broadcast-to-everyone mechanism —
+# --broadcast and @everyone were removed by design; name every recipient
+# explicitly (--to is repeatable for multiple recipients).
 thrum send --mention @implementer --stdin <<'EOF'
 BLOCKED: {{TASK_ID}} — waiting for {{BLOCKER_ID}}. Can you prioritize?
 EOF
@@ -603,18 +616,25 @@ Fix any failures before proceeding. Do not submit broken code for review.
 
 ### Step 2: Spec Compliance Review (Stage 1)
 
-Verify the implementation covers everything specified in the plan, design doc,
-and each task's acceptance criteria. No code-style judgments at this stage —
-only "does the code do what was asked?"
+Verify the implementation covers everything specified in the plan and, when the
+epic has a design doc, in the design doc. Also cross-check each task's
+acceptance criteria against the code: run
+`bd show <task_id>` for every task in the epic and confirm each acceptance
+criterion is met. No code-style judgments at this stage — only "does the code do
+what was asked?"
 
 Invoke `verify-against-plan` with these inputs:
 
 ```text
-/verify-against-plan plan={{PLAN_FILE}} branch={{BRANCH_NAME}}
+/verify-against-plan plan={{PLAN_FILE}} design={{DESIGN_DOC}} branch={{BRANCH_NAME}}
 ```
 
+Drop the `design=` input only when this epic has no design doc (`{{DESIGN_DOC}}`
+was left unset). With it, requirements that only the design states are checked
+too, not just the plan's tasks.
+
 The skill produces structured `BLOCKING` / `IMPORTANT` / `MINOR` findings with
-plan-reference + file:line evidence.
+plan-reference (or design-reference) + file:line evidence.
 
 **When findings come back:**
 
@@ -643,7 +663,7 @@ results before proceeding). The reviewer is a separate agent — you cannot
 influence its findings.
 
 ```text
-Agent(subagent_type="feature-dev:code-reviewer", model="sonnet",
+Agent(subagent_type="feature-dev:code-reviewer", model="<per choosing-subagent-models>",
   prompt="Review code quality of the implementation on branch {{BRANCH_NAME}}
   in {{WORKTREE_PATH}}. Focus only on quality of the code that was written —
   spec compliance is covered separately by verify-against-plan.
@@ -814,7 +834,7 @@ the minimal sequence:
 cd {{WORKTREE_PATH}}
 thrum quickstart --name {{AGENT_NAME}} --role implementer --module {{BRANCH_NAME}} --intent "Resuming {{EPIC_ID}}"
 thrum inbox --unread
-# Tip: thrum inbox --unread peeks without marking read; thrum message read --all to mark all read
+# Tip: thrum inbox --unread peeks without marking read; thrum message read --all --force to mark all unread (run `--all` alone first — dry run)
 # Tip: default page is 10 newest-first — stale unread sorts LAST; use `thrum message search "<term>"` to find it
 
 # 2. Orient from beads and git

package/assets/skills/researcher-answering-queries/SKILL.md

@@ -75,8 +75,7 @@ where inlining is genuinely cheaper than the round-trip.
 
 ## 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 `researcher-maintaining-memory` skill — it references the

package/assets/skills/researcher-investigating/SKILL.md

@@ -24,16 +24,13 @@ specific symbol, or a specific question. Get a focused report back. For research
 across N > 6 items, invoke `efficient-multi-agent-research` instead of bespoke
 dispatch — it handles partition + parallelization + consolidation.
 
-> **Model tiers:** pass an explicit `model:` on every dispatch — `sonnet`
-> (low effort) mechanical, `sonnet` (medium effort) judgment, Opus only on
-> operator-ask or a skill step that names it. See the
-> `choosing-subagent-models` skill for the full policy.
+> **Model tiers:** pass an explicit `model:` on every dispatch; choose model and effort per the `choosing-subagent-models` skill (read `runtime.role_models` at the moment of use). Never let a sub-agent inherit your own model.
 
 ### Prefer `efficient-multi-agent-research` for multi-part research
 
 When a research or investigation task has independent parts, reach for the
 `efficient-multi-agent-research` skill FIRST — it partitions the work across
-many cheap parallel subagents (sonnet-low gatherers, sonnet-medium synthesizers) instead of
+many cheap parallel subagents (cheap gatherers, judgment-tier synthesizers) instead of
 one expensive serial subagent. It is the preferred research path: cheaper,
 faster, and it keeps each subagent's context tight.
 
@@ -77,8 +74,8 @@ sessions and re-readable by other agents.
 
 **How to apply:** After reporting to the requester, write the finding as a
 `research_note` memory with cited file:line refs and a verification footer. Tag
-with a `research-<slug>` handle so other agents can find it later via
-`thrum memory search --tag research-<slug>`:
+it with `--tag <slug>` so other agents can find it later via
+`thrum memory search --tag <slug>`:
 
 ```bash
 cat > /tmp/research-note-body.md <<EOF
@@ -88,19 +85,18 @@ Verified: $(date +%Y-%m-%d) @ $(git rev-parse HEAD)
 EOF
 thrum memory create --kind research_note --scope role \
   --title "<finding prose, ~80 char soft limit>" \
-  --tag research-<slug> \
+  --tag <slug> \
   --oneline "<one-line summary>" \
   --full "@/tmp/research-note-body.md"
 ```
 
 `--full` here is multi-line prose — compose via heredoc or a captured
-variable, never double-quoted inline like this; see your role preamble's 🔴
-PROSE INTO A COMMAND rule.
+variable, never double-quoted inline like this; see the heredoc-or-file rule in your role preamble.
 
 Then add one line to `.thrum/context/research.md` under Tracked Topics (note: `thrum queue` now supersedes free-text Open Questions tracking):
 
 ```markdown
-- `research-<slug>` — <one-line description, ≤ 80 chars>
+- `<slug>` — <one-line description, ≤ 80 chars>
 ```
 
 The full index format and staleness-check protocol live in
@@ -124,8 +120,7 @@ gaps — you surface them, the implementer ships them.
 
 ## 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 `researcher-maintaining-memory` skill — it references the

package/assets/skills/researcher-maintaining-memory/SKILL.md

@@ -158,7 +158,7 @@ thrum memory create --kind agent_rule --scope role \
 ```
 
 `--short`/`--full` carry real prose — compose via heredoc or file, never
-double-quoted inline; see your role preamble's 🔴 PROSE INTO A COMMAND rule.
+double-quoted inline; see the heredoc-or-file rule in your role preamble.
 
 This is the SAME pattern as coordinator/implementer role-rule writes — see
 `memory-write-discipline` for the canonical shape.

package/assets/{commands/thrum-_snapshot-protocol.md → skills/snapshot-protocol/SKILL.md}

@@ -1,32 +1,32 @@
 ---
-description:
-  Shared snapshot-composition protocol consumed by the snapshot-save commands.
-  Not user-invocable directly.
+name: snapshot-protocol
+description: "Use when composing a restart snapshot or continuation - snapshot structure, worktree resolution, write rules."
 ---
 
-# Snapshot Composition Protocol (shared partial)
 
-Consumers: run `grep -rl _snapshot-protocol claude-plugin/commands/` for the
-current set — do NOT hardcode it here. A list of consumers inside the consumed
-file is a second copy of a git-answerable fact and rots the moment a command is
-added or dropped. Note: plain `/thrum:restart` does NOT consume this partial; it
-carries its own inline snapshot template.
+# Snapshot Composition Protocol
+Note: plain `/thrum:restart` carries its own inline snapshot template rather
+than consuming this skill.
 
-This is the canonical source-of-truth for snapshot composition discipline. The
-sibling commands that consume this partial compose: read this partial →
-variant-specific terminal action. Do NOT invoke this file directly; it has no
+This is the canonical source-of-truth for snapshot composition discipline.
+Invoke this skill to compose a snapshot, then take the variant-specific
 terminal action.
 
 ## Step 1 — Resolve identity and your worktree
 
 ```bash
 # $REPO must be YOUR worktree — the directory `thrum prime` reads the restart
-# snapshot back from. Resolve it from the daemon's authoritative identity, NOT
-# `git rev-parse` (which keys off the current shell CWD and would write to the
-# wrong .thrum/restart/ if a bash step left your worktree). Fall back to git
-# only if whoami can't answer.
-REPO=$(thrum whoami --field worktree 2>/dev/null)
-[ -n "$REPO" ] || REPO=$(git rev-parse --show-toplevel) || { echo "ERROR: cannot resolve your worktree"; exit 1; }
+# snapshot back from. Resolve it ONLY via the daemon's authoritative,
+# peercred-resolved identity (`thrum agent worktree --authoritative`) — NEVER
+# via `thrum whoami --field worktree` (cwd-resolved) or `git rev-parse
+# --show-toplevel` (also cwd-resolved). A cwd-derived pattern
+# could silently resolve to a DIFFERENT agent's worktree, or the main repo,
+# saving this snapshot where nothing ever reads it back. There is NO git
+# fallback — if the daemon can't answer, refuse and stop rather than guess.
+REPO=$(
+  thrum agent worktree --authoritative 2>/dev/null
+) || { echo "ERROR: cannot authoritatively resolve your worktree via the daemon. Refusing to fall back to cwd/git-toplevel — that would risk silently saving this snapshot to the wrong repo. Check daemon connectivity and retry."; exit 1; }
+[ -n "$REPO" ] || { echo "ERROR: thrum agent worktree --authoritative returned empty"; exit 1; }
 AGENT=$(thrum whoami --field agent_id) || { echo "ERROR: agent not registered"; exit 1; }
 [ -n "$AGENT" ] || { echo "ERROR: empty agent_id"; exit 1; }
 mkdir -p "${REPO}/.thrum/restart"
@@ -66,14 +66,14 @@ shapes everything else you write below it.
 
 **Stamp your snapshot with the base it was authored against.**
 Derive and emit the **Authored-against** stamp per
-`claude-plugin/commands/_stamp-protocol.md` and place it at the very top of your
+the /thrum:stamp-protocol skill and place it at the very top of your
 §1 section (that protocol computes the SHA and merge_target for you — never
 hand-type them). This is what lets `thrum prime` diff your snapshot at the next
 wake and flag which cited files have MOVED; an unstamped snapshot reads as
 "current", indistinguishable from one that never drifted.
 
 Any commit your snapshot names as its own stamped SHA must also be readable
-under `_stamp-protocol.md`'s "Read-time provenance re-derivation" section
+under `stamp-protocol.md`'s "Read-time provenance re-derivation" section
 (SHA-resolves, then merge-status) — link to that section rather than restating
 its checks here.
 
@@ -109,7 +109,7 @@ session's conversation context. Refer to the previous session in third person.
 
 ### Choose your structure
 
-The variant skill that invoked this partial tells you which structure to use:
+The variant skill that invoked this skill tells you which structure to use:
 
 - **`/thrum:sleep`** → use the STANDARD 11-section structure below.
 - **`/thrum:restart-extended` and `/thrum:sleep-extended`** → use the EXTENDED
@@ -261,5 +261,11 @@ ${REPO}/.thrum/restart/${AGENT}.md
 comes from `thrum tmux restart` or `thrum tmux create`). No bash heredoc or
 `cat <<EOF` redirection is needed — write the file directly.
 
+Variants that have a verify step (`/thrum:compact`, `/thrum:compact-extended`,
+`/thrum:restart`, `/thrum:restart-extended`) mint a `SNAPSHOT_PATH` and
+`SNAPSHOT_NONCE` in their own Step 3 PREP block: write to exactly that path, end
+the file with `<!-- snapshot-nonce: <nonce> -->`, and record both for the verify
+block. The sleep variants have no verify block and need no nonce.
+
 After writing, return control to your variant skill (`/thrum:restart-extended`,
 `/thrum:sleep`, or `/thrum:sleep-extended`) for the terminal action.

package/assets/{commands/thrum-_stamp-protocol.md → skills/stamp-protocol/SKILL.md}

@@ -1,15 +1,14 @@
 ---
-description:
-  Shared Authored-against stamp protocol — canonical format, derivation
-  commands, and never-type rule. Not user-invocable directly.
+name: stamp-protocol
+description: "Use when stamping a plan, prompt, or snapshot - Authored-against format, derivation commands, never-type rule."
 ---
 
-# Authored-against Stamp Protocol (shared partial)
 
+# Authored-Against Stamp Protocol
 This is the canonical source-of-truth for the Authored-against stamp: its format,
 derivation commands, and the never-type rule. Consuming files point here instead of
-restating the recipe. Do NOT invoke this file directly; it has no terminal action.
-(To find what currently points here: `grep -rn "_stamp-protocol.md" claude-plugin/`
+restating the recipe. Do not run this as a command; it has no terminal action — other skills and commands load it by name.
+(To find what currently points here: `grep -rn "thrum:stamp-protocol" claude-plugin/commands/ claude-plugin/skills/`
 — a hand-listed consumer roster in this file would rot the moment a new emitter or
 reader is added, so none is kept here.)
 
@@ -46,8 +45,15 @@ diffs if the remote-tracking ref might be stale.
 # SHA of the current HEAD
 git rev-parse HEAD
 
-# Configured merge target
-jq -r '.orchestration.merge_target' .thrum/config.json
+# Configured merge target -- resolve through .thrum/redirect when present.
+# A worktree's .thrum/ holds only a `redirect` file (a single line: the
+# absolute path to the MAIN REPO'S .thrum directory itself), not its own
+# config.json -- reading .thrum/config.json directly from a worktree
+# silently returns empty. Root repos have no redirect file, so CONFIG falls
+# through to the direct path.
+CONFIG=".thrum/config.json"
+[ -f .thrum/redirect ] && CONFIG="$(cat .thrum/redirect)/config.json"
+jq -r '.orchestration.merge_target' "$CONFIG"
 ```
 
 The author must never type or remember either value by hand — both come from the

package/assets/skills/thrum/SKILL.md

@@ -8,8 +8,9 @@ license: "Apache-2.0"
 
 # Thrum - Git-Backed Multi-Agent Coordination (Messaging, Groups, Shared Context)
 
-Run `thrum prime` for full session context (auto-injected by hooks on
-SessionStart and PreCompact).
+Run `thrum prime` for full session context (auto-injected by the SessionStart
+hook; also fires on post-compact resume). PreCompact is not registered — use
+`/thrum:compact` to save a snapshot before deliberately compacting.
 
 ## Quick Command Reference
 
@@ -17,19 +18,23 @@ SessionStart and PreCompact).
 
 ```bash
 thrum send --to @name --body-file msg.md           # Direct message (body from file)
-thrum send --broadcast --body-file msg.md          # Team-wide fanout
-thrum send --to @everyone --body-file msg.md       # Broadcast (legacy keyword; --broadcast preferred)
+thrum send --to @name1 --to @name2 --body-file msg.md   # Multiple explicit recipients (repeatable --to)
 thrum reply <msg-id> --body-file reply.md          # Reply (same audience; NO --to — recipient comes from the message)
 thrum inbox                              List messages (auto-marks displayed as read)
 thrum inbox --unread                     Unread only (does not mark as read)
 thrum message search "<term>"            Full-text search — use instead of paging; stale unread sorts last
 thrum sent                               List messages you sent
 thrum sent --unread                      Sent messages with unread recipients
-thrum message read --all                 Mark all messages as read
+thrum message read --all --force         Mark ALL unread as read (run `read --all` alone first — dry run)
 thrum wait                               Block until message arrives (30s timeout)
 thrum wait --timeout 120s                Custom timeout (duration)
 ```
 
+One-to-many fan-out (`--broadcast`, `@everyone`, role-based mentions/groups)
+was removed by design (P0 ruling); do not restore it. Name
+every recipient explicitly with repeatable `--to @name`, or address a scoped
+agent-type group.
+
 ### Agents
 
 ```bash
@@ -140,8 +145,10 @@ processing. See [LISTENER_PATTERN.md](resources/LISTENER_PATTERN.md).
 ### Context Management
 
 - `thrum prime` gathers identity, team, inbox, git context, sync health
-- SessionStart hook auto-runs `thrum prime` on session start
-- PreCompact hook saves state to thrum context + `/tmp` backup before compaction
+- SessionStart hook auto-runs `thrum prime` on session start (including
+  post-compact resume)
+- PreCompact is NOT registered — run `/thrum:compact` to save a restart
+  snapshot deliberately before compacting
 - **After compaction:** run `/thrum:load-context` to restore your work context
 - Agent identity persists in `.thrum/identities/`
 

package/assets/skills/thrum/resources/ANTI_PATTERNS.md

@@ -26,9 +26,9 @@ Task(subagent_type="message-listener", run_in_background=true, prompt="...")
 
 ## 4. Sending Without an Explicit Recipient Flag
 
-`thrum send 'msg'` with no `--to` or `--broadcast` is a hard error. The
-previous default — silent broadcast to every team agent — was a real footgun,
-so the CLI now requires the recipient to be explicit:
+`thrum send 'msg'` with no `--to` is a hard error. The previous default —
+silent broadcast to every team agent — was a real footgun, so the CLI now
+requires the recipient to be explicit:
 
 ```bash
 # Wrong — hard-errors with a "missing recipient" prompt
@@ -39,19 +39,15 @@ thrum send --to @your_coordinator --stdin <<'EOF'
 msg
 EOF
 
-# Right — explicit team-wide fanout
-thrum send --broadcast --stdin <<'EOF'
-msg
-EOF
-
-# Right — legacy keyword form (still works; --broadcast preferred)
-thrum send --to @everyone --stdin <<'EOF'
+# Right — repeatable --to for multiple explicit recipients
+thrum send --to @alice --to @bob --stdin <<'EOF'
 msg
 EOF
 ```
 
-`--to` and `--broadcast` are mutually exclusive. `@everyone` continues to be
-auto-created and handles membership dynamically.
+(P0 ruling): `--broadcast` and `@everyone` were removed by
+design; do not restore them. There is no team-wide fanout — name every
+recipient explicitly, or address a scoped agent-type group.
 
 ## 5. Skipping Registration
 
@@ -102,14 +98,16 @@ finishing the main task.
 Include Beads IDs, file paths, commit hashes — anything that helps the recipient
 act on the message.
 
-## 12. Using @role to Address One Agent
+## 12. Assuming @role Fans Out to a Role's Agents
 
-**Wrong:** `thrum send --to @implementer --body-file msg.md` — fans out to all
-implementers. **Right:** `thrum send --to @alice --body-file msg.md` — use the
-agent's name.
+**Wrong:** assuming `thrum send --to @implementer --body-file msg.md` reaches
+every implementer. **Right:** `thrum send --to @alice --body-file msg.md` —
+use the agent's name.
 
-`@role` sends to **all agents** with that role (via the auto-created role group)
-and emits a warning. Use `@name` for direct messages. Check names with
+(P0 ruling): role-based mention/group fan-out was removed by
+design; do not restore it. `--to` and `--mention` only resolve exact agent
+IDs — `@implementer` matches nobody unless an agent is literally named
+`implementer`. Use `@name` for direct messages. Check names with
 `thrum team`.
 
 ## 13. Sending to Unknown Recipients

package/assets/skills/thrum/resources/CLI_REFERENCE.md

@@ -60,20 +60,23 @@ Full reference: [docs/cli-hints.md](https://thrum.team/docs/cli-hints.html)
 
 ```bash
 thrum send --to @name --body-file ./body.md          # Direct message (canonical form)
-thrum send --broadcast --body-file ./body.md         # Explicit team-wide fanout (preferred)
-thrum send --to @everyone --body-file ./body.md      # Broadcast (legacy keyword form)
+thrum send --to @name1 --to @name2 --body-file ./body.md   # Multiple explicit recipients (repeatable --to)
 thrum send --to @name --scope type:value --scope type:value2 --body-file ./body.md
 thrum send --to @name --ref type:value --body-file ./body.md
-thrum send --to @name --mention @role --body-file ./body.md
+thrum send --to @name --mention @other_agent --body-file ./body.md
 thrum send --to @name --format plain --body-file ./body.md
 thrum send --to @name --structured '{"key":"value"}' --body-file ./body.md
 thrum send --to @name --body-file ./body.md          # Shell-safe body (file)
 generator | thrum send --to @name -                  # '-' is a --stdin alias
 ```
 
-A recipient flag is REQUIRED — `thrum send 'msg'` with no `--to` or
-`--broadcast` is a hard error. `--to` and `--broadcast` are
-mutually exclusive.
+A recipient flag is REQUIRED — `thrum send 'msg'` with no `--to` is a hard
+error.
+
+(P0 ruling): `--broadcast` and `@everyone` were removed by
+design across the whole product; do not restore them. There is no one-to-many
+fan-out — name every recipient explicitly with repeatable `--to`, or address a
+scoped agent-type group.
 
 Shell-safe bodies: backticks, `$(...)`, `$VAR`, and quotes in a
 double-quoted message are interpreted by the shell BEFORE thrum runs, silently
@@ -85,9 +88,8 @@ trailing newline is stripped from stdin/file bodies.
 Flags:
 
 ```text
---to string           Recipient — @agent_name or @everyone for broadcast (mutex with --broadcast)
---broadcast           Fan out to the entire team (mutex with --to)
---mention strings     Mention a role (repeatable, format: @role)
+--to strings          Recipient — @agent_name, explicit only (repeatable; no @everyone/@role fan-out)
+--mention strings     Mention an explicit agent (repeatable, format: @agent_name)
 --ref strings         Add reference (repeatable, format: type:value)
 --scope strings       Add scope (repeatable, format: type:value)
 --format string       Message format: markdown, plain, json (default "markdown")
@@ -198,7 +200,9 @@ thrum message edit <msg-id> --body-file ./new-body.md  # Full replacement (autho
 thrum message edit <msg-id> --body-file ./new.md  # Full replacement from file
 thrum message delete <msg-id> --force          # Delete (--force required)
 thrum message read <msg-id> [<msg-id>...]      # Mark as read
-thrum message read --all                       # Mark all as read
+thrum message read --all                       # DRY RUN: list what --apply/--force would mark, marks nothing
+thrum message read --all --apply               # Mark the shown (already-seen) candidates
+thrum message read --all --force               # Mark ALL unread, seen or not (needs a fresh `--all` dry run first)
 thrum message search "<term>"                  # Full-text search across all messages (see § inbox above)
 thrum message reindex                          # Rebuild the FTS index if search looks wrong
 ```
@@ -214,7 +218,9 @@ Subcommand flags:
 --force   Confirm deletion (required)
 
 # message read
---all     Mark all unread messages as read
+--all     List seen+unread candidates (dry run); combine with --apply or --force to mark
+--apply   With --all: mark the shown (already-seen) candidates
+--force   With --all: mark ALL unread, seen or not (needs a fresh --all dry run first)
 ```
 
 ---

package/assets/skills/thrum/resources/LISTENER_PATTERN.md

@@ -4,6 +4,12 @@
 > at zero token cost with no background listener needed. See
 > [TMUX_SESSIONS.md](TMUX_SESSIONS.md). Use the listener pattern below when tmux
 > is not available or not practical for your setup.
+>
+> **Deprecated for newly initialized agents:** the hook injection and
+> scheduled backstop that `thrum init` installs deliver message nudges without a
+> listener. The pattern below still works and is supported, but it holds tokens in
+> the agent's context for the entire session. Cross-runtime agents (codex, cursor,
+> etc.) without hook support still use it.
 
 The message-listener is a background sub-agent that blocks on `thrum wait` and
 returns when messages arrive. A PID file (`.thrum/var/<agent_id>-listener.pid`)
@@ -14,7 +20,7 @@ prevents duplicate listeners — spawning when one is already running is safe.
 ```text
 Task(
   subagent_type="message-listener",
-  model="sonnet",  # low effort
+  model="<per choosing-subagent-models>",  # cheapest tier
   prompt="Listen for Thrum messages.\nSTEP_1: /path/to/repo/scripts/thrum-startup.sh --listener-heartbeat\nSTEP_2: thrum wait --timeout 8m --after -15s --agent-name <agent_id>"
 )
 ```
@@ -49,7 +55,7 @@ Automatically respawn the listener if it dies or is lost after compaction.
 ```text
 CronCreate(
   cron="*/30 * * * *",
-  prompt="Check the listener PID file at .thrum/var/<agent_id>-listener.pid.\nIf the file does not exist, or if kill -0 <pid> fails (process not running),\nspawn a new listener:\n\nAgent(subagent_type=\"message-listener\", model=\"sonnet\", prompt=\"Listen for Thrum messages.\\nSTEP_1: /path/to/repo/scripts/thrum-startup.sh --listener-heartbeat\\nSTEP_2: thrum wait --timeout 8m --after -15s --agent-name <agent_id>\")"
+  prompt="Check the listener PID file at .thrum/var/<agent_id>-listener.pid.\nIf the file does not exist, or if kill -0 <pid> fails (process not running),\nspawn a new listener:\n\nAgent(subagent_type=\"message-listener\", model=\"<per choosing-subagent-models>\", prompt=\"Listen for Thrum messages.\\nSTEP_1: /path/to/repo/scripts/thrum-startup.sh --listener-heartbeat\\nSTEP_2: thrum wait --timeout 8m --after -15s --agent-name <agent_id>\")"
 )
 ```
 
@@ -60,5 +66,5 @@ Spawn the initial listener on session start, then create the cron watchdog.
 - **Spawn freely** — PID file prevents duplicates
 - **Return immediately** when messages arrive (don't wait for more)
 - **Read-only** — the listener never sends messages
-- **Cost-efficient** — runs on sonnet-low, blocks instead of polling
+- **Cost-efficient** — runs on a cheap tier, blocks instead of polling
 - Listener uses CLI only (`Bash` tool), not MCP tools