opencode-thrum-pro 0.1.0

package/assets/commands/thrum-_deviations-protocol.md

@@ -0,0 +1,87 @@
+---
+description:
+  Shared Deviations-from-Source protocol — canonical block format, the
+  required-even-when-empty rule, and derivation discipline. Not
+  user-invocable directly.
+---
+
+# Deviations from Source Protocol (shared partial)
+
+This file is the canonical source-of-truth for the "Deviations from Source"
+block emitted by planning-loop artifacts (plans, implementation prompts). Do
+NOT invoke this file directly; it has no terminal action.
+
+(To find what currently points here: `grep -rn "_deviations-protocol.md"
+claude-plugin/` — a hand-listed consumer roster in this file would rot the
+moment a new emitter or reader is added, so none is kept here.)
+
+## Purpose
+
+Dilution is a deletion: when a reviewer's feasibility objection causes a
+requirement to be quietly dropped or weakened while converting one artifact
+into the next (spec → plan → prompt), the loss leaves no artifact — you
+cannot grep for an absence. Every downstream step remains internally
+consistent with the step directly above it, so every review passes even
+though intent was lost several steps back.
+
+The fix is the same move as pairing every zero with a control: since an
+absence cannot be verified, force it to be STATED. An artifact that dropped
+or weakened nothing must say so explicitly ("No deviations from source.");
+an artifact that is silent on deviations is untrustworthy by construction and
+FAILS the gate, whether or not it actually dropped anything.
+
+## Format (emitted artifact — verbatim)
+
+Every plan and implementation prompt carries this heading, placed immediately
+after its Authored-against stamp block (see `_stamp-protocol.md`):
+
+```
+## Deviations from Source
+
+No deviations from source.
+```
+
+If anything was dropped or weakened relative to the declared source
+artifact(s), replace the single line above with one bullet per deviation:
+
+```
+## Deviations from Source
+
+- DROPPED: <requirement, quoted or closely paraphrased from the source> —
+  why: <reason it was dropped/weakened> — source: <file:line or section ref>
+  — attribution: <"owner decision" | "reviewer objection unresolved">
+```
+
+**The heading is REQUIRED even when the list is empty.** "No deviations from
+source." is not boilerplate — it is a claim a human made that a reviewer can
+check against the actual diff between artifact and source. An artifact
+missing this heading entirely has not been checked and must fail the gate
+that looks for it (see `project-setup/SKILL.md` Phase 0).
+
+## Derivation rule
+
+Derive the block by DIFFING the artifact against its actual, currently-read
+source document or decision list — never by recalling from memory what was
+probably dropped. No git diff can see an absence, so the author must state it
+directly, freshly re-derived at authoring time, not carried forward from a
+prior cycle.
+
+## Attribution values
+
+Each deviation item is attributed to exactly one of:
+
+- `owner decision` — the intent-owner explicitly agreed to cut or weaken the
+  requirement.
+- `reviewer objection unresolved` — a reviewer raised a feasibility
+  objection that has NOT yet been resolved by the intent-owner; this
+  attribution is a FLAG, not a resolution, and must route to the
+  intent-owner per the feasibility-escalation rule (see
+  `coordinator-running-brainstorm-cycles/SKILL.md`) rather than being folded
+  in silently.
+
+## Format conventions
+
+The `## Deviations from Source` heading is grep -F-matchable: exact case,
+exact text, no variant headings. `project-setup/SKILL.md` Phase 0 gates on
+its literal presence with `grep -F '## Deviations from Source'`. Do not
+reword, recase, or relocate the heading.

package/assets/commands/thrum-_generator-idempotency-protocol.md

@@ -0,0 +1,15 @@
+---
+description:
+  Shared generator-skill idempotency invariant consumed by config/doc
+  generator skills. Not user-invocable directly.
+---
+
+# Generator Idempotency Protocol (shared partial)
+
+Consumers: run `grep -rl _generator-idempotency-protocol claude-plugin/skills/`
+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
+skill is added or dropped.
+
+The modes are idempotent — running the skill repeatedly on a stable project
+should produce no file changes after the first run.

package/assets/commands/thrum-_project-rules-protocol.md

@@ -0,0 +1,18 @@
+---
+description:
+  Shared project-specific-rules protocol consumed by role skills. Not
+  user-invocable directly.
+---
+
+# Project-Specific Rules Protocol (shared partial)
+
+Consumers: run `grep -rl _project-rules-protocol claude-plugin/skills/` 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 skill is
+added or dropped.
+
+Project-local rules of kind `agent_rule` at `--scope role` were loaded at
+session start by your preamble (see your role template's Memory model block).
+If a project-local rule conflicts with a universal rule above, the
+project-local rule wins; surface the conflict in your reply so the user can
+decide whether to graduate or remove the override.

package/assets/commands/thrum-_snapshot-protocol.md

@@ -0,0 +1,265 @@
+---
+description:
+  Shared snapshot-composition protocol consumed by the snapshot-save commands.
+  Not user-invocable directly.
+---
+
+# 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.
+
+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
+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; }
+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"
+```
+
+## Step 2 — Compose your continuation
+
+### Composition discipline (always applies)
+
+Your context is high (or you are preparing to park) and the goal is to preserve
+all load-bearing decisions across the session boundary. Write a rich
+continuation that future-you will read as the first action after wake.
+
+**§1 of your snapshot is REQUIRED FIRST PROSE.** Write the "Big picture — what
+shipped this session" (or, for sleep snapshots, "where work stands at park
+time") section BEFORE anything else. Be specific: name the artifacts, the
+decisions, the cycles closed. Examples:
+
+> Locked the session-archive spec v2 with §1 Big picture requirement, five
+> Q-Spec approvals, and Q-Spec-5 deferred to impl-time. Hand-off pending
+> coordinator final review.
+>
+> Investigated rc.9 inbox-race against <implementer>'s hypothesis: confirmed
+> the lock-substrate fence is the right fix. Filed thrum-XXX with 4 BLOCKING
+> evidence points.
+>
+> Closed <epic> brainstormer-third pass. 2 BLOCKING + 5 IMPORTANT + 10 MINOR.
+> All three load-bearing traps PASSed. Standing by for <epic> next batch.
+
+This section becomes YOUR OWN log entry, visible in `thrum agent sessions list`
+alongside the archives of every other session you've ever restarted from.
+Future-you (and other agents inspecting your history) skim §1 to decide which
+sessions are worth re-reading. Write it first — before the Resume Plan, before
+file paths, before patterns — because composing the §1 summary forces you to
+identify what was actually load-bearing about this session, and that priority
+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
+§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
+(SHA-resolves, then merge-status) — link to that section rather than restating
+its checks here.
+
+**Describe commits, don't claim them.** A snapshot's job is to describe what a
+commit's content and effect ARE — that's checkable by anyone re-reading it.
+Prohibit first-person narration of git actions in the body of a snapshot:
+no "I pushed X", "I fixed Y and verified it", "I ran Z". Write instead:
+"commit `<sha>` exists and does `<Y>`" / "`<sha>` addresses `<Y>`". Attribution
+of WHO performed a git action already lives in `command.jsonl` / `hooklog.jsonl`
+— restating it here would assert authorship the snapshot-writer has typically
+never mechanically verified.
+
+After the §1 block:
+
+CRITICAL DISCIPLINE — compose from your own working context only. To preserve
+the remaining runway:
+
+- Do NOT dispatch sub-agents (Agent, Explore, etc.)
+- Do NOT re-read files you've already read this session
+- Do NOT spawn web fetches or external lookups
+- Do NOT run lengthy investigations (git log spelunking, codebase searches,
+  multi-file grep walks)
+
+Each of those costs context you don't have to spend, and the cost compounds — a
+sub-agent that returns 6K tokens of summary doesn't just cost the dispatch, it
+pollutes the dying session further. If a fact isn't already in your working
+context, label it "unknown" or "verify post-restart" rather than fetching it
+now. Trust your in-context state.
+
+Write for a competent stranger in your role — someone who has the runtime
+briefing (`thrum prime`, role preamble, project state) but none of this
+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:
+
+- **`/thrum:sleep`** → use the STANDARD 11-section structure below.
+- **`/thrum:restart-extended` and `/thrum:sleep-extended`** → use the EXTENDED
+  16-section structure below.
+
+The standard structure is the working compact format. The extended structure is
+fundamentally different: a comprehensive technical reference (wire contracts,
+capability matrix, anticipated Q&A, design rationale) appropriate for
+designer/architect-grade handoffs where the next session may be cold and must
+recover the full design grammar from this artifact alone.
+
+### Standard structure (11 sections)
+
+Use these numbered sections (write each as prose or table — your call — but the
+numbered structure itself should be present):
+
+1. **Big picture** — what shipped this session (REQUIRED FIRST, written above
+   per the §1 mandate).
+2. **Where every artifact stands** — branches, specs, plans, in-flight PRs,
+   partially-landed work. Concrete tips / paths / commit SHAs.
+3. **Players + contributions** — who's working on what, who's standing down,
+   what each agent's latest state is.
+4. **Decisions made this session** — with the context that drove each. Just
+   listing the decision loses the reasoning future-you needs to judge edge
+   cases.
+5. **Questions awaiting repo owner input** — anything queued for the project
+   owner's call before work can proceed. Name the question concretely.
+6. **Outstanding work you owe** — commitments still open on your side (pushes,
+   merges, dispatches, doc-patches).
+7. **Patterns that worked / burned us** — short reflective section: what to keep
+   doing, what to stop. Two sub-sections is enough.
+8. **File paths future-you will reopen** — concrete paths the next session will
+   need. Group by purpose (in-flight / queued / reference).
+9. **Numbered resume plan** — concrete first-N-steps the next session should
+   take, in order. Step 1 must be actionable from a cold start.
+10. **Honest unknowns — verify post-restart, do NOT fabricate** — list facts you
+    suspect changed during the session OR were never confirmed in the first
+    place. Future-you must NOT carry these forward as truth until they're
+    verified.
+11. **End-of-continuation note** — one short paragraph reflecting on the session
+    itself.
+
+Skip a section only when it genuinely doesn't apply — an honest "N/A: no
+decisions this session" beats fabrication. The numbered structure itself should
+always be present so future-you can scan for what's covered and what isn't.
+
+### Extended structure (16 sections)
+
+Numbered `§1.` through `§16.`. The §-prefix is intentional — extended snapshots
+use a visually distinct convention from standard to signal grade difference.
+Each section names a concern; write as prose, a table, or omit with an explicit
+"N/A: <reason>" rather than skipping silently.
+
+```text
+§1.  Header block — author / date / restart reason / restart-you mandate / context-percent at write time
+§2.  Identity — agent_id / worktree path / branch / role / coordinator name / cut-point commit SHA
+§3.  Big picture — what shipped this session  [REQUIRED FIRST PROSE — mirrors standard §1]
+§4.  Mission state — where this work currently sits in its pipeline
+§5.  Locked design decisions — operator-LOCKs, design-fork resolutions, with rationale
+§6.  Open L-questions parked for the operator — or "NONE: <reason>" with explicit note
+§7.  Wire contracts — durable technical reference (types, signatures, file:line cites)
+§8.  Capability matrix — per-surface contracts (row-by-row table for fanout work; OMIT if N/A)
+§9.  Design inventory — locked taxonomy (entanglement classes, patterns, anti-patterns; OMIT if N/A)
+§10. Cycle history — review cycles run, findings, fold record (OMIT if pre-review-phase)
+§11. Pipeline state — DAG of artifacts (brainstorm → plan → impl → review) with current cursor
+§12. Pre-restart artifacts on disk — durable handoff manifest (table: artifact / path / status)
+§13. Anticipated Q&A — questions restart-you or downstream implementer will ask, pre-answered
+§14. References — bd IDs, commit anchors, memories, file paths, message IDs (load-bearing for transcript recon)
+§15. Honest unknowns — verify post-restart, do NOT fabricate
+§16. Restart-you's immediate next actions — numbered; step 1 actionable from cold start
+```
+
+**Per-section guidance:**
+
+- **§1 Header.** Top of file. Author (agent_id), date, restart reason (1-line
+  trigger), one-sentence mandate to restart-you ("read this in full, then [N
+  specific actions]"), context-% at write time. Read-first prominence.
+- **§2 Identity.** `agent_id` / worktree absolute path / branch / role /
+  coordinator name / cut-point commit SHA for any line cites that follow.
+  Mechanical; lets a totally cold restart-you orient before reading any prose.
+- **§3 Big picture.** REQUIRED FIRST PROSE. 1–3 sentences summarizing what the
+  session accomplished. Specific: artifacts, decisions, cycles closed. Becomes
+  the session-archive log entry. Write this BEFORE anything else (composing §3
+  forces you to identify what was load-bearing, which shapes what you write
+  below). **Sleep variant:** for `/thrum:sleep` and `/thrum:sleep-extended`, §3
+  frames as "where work stands at park time" rather than "what shipped" — the
+  agent is parking, not completing. Composition discipline (1–3 sentences,
+  specific, load-bearing-first) is identical.
+- **§4 Mission state.** Where this work sits in its pipeline. Not the pipeline
+  DAG itself (that's §11) — the narrative status.
+- **§5 Locked design decisions.** Each LOCK gets a line: decision + the
+  operator's wording (when applicable) + rationale.
+- **§6 Open L-questions.** Numbered Q-list with researcher recommendations. OR
+  "NONE: all locked per <evidence>" with the evidence cited.
+- **§7 Wire contracts.** Durable technical reference — types, function
+  signatures, struct field lists, file:line cites. Cut from the live tree at
+  §2's cut-point SHA. **Format:** use fenced code blocks for type signatures and
+  struct fields; use inline `file:line` citations anchored to §2's cut-point SHA
+  so future-you can `git show <SHA>:<file>` to reproduce.
+- **§8 Capability matrix.** Row-by-row table when work fans out across N call
+  sites / migration surfaces / per-symbol concerns. **OMIT criterion:** OMIT
+  when work is single-call-site or single-surface. **REQUIRED criterion:**
+  required when the session covered changes across ≥2 independent call sites /
+  migration surfaces / per-symbol concerns. When in doubt, include — a one-row
+  table is cheaper than a missing one.
+- **§9 Design inventory.** Locked taxonomy: entanglement classes, pattern
+  catalogue, anti-patterns. **OMIT criterion:** OMIT when the work hasn't yet
+  developed a stable design grammar. **REQUIRED criterion:** required when ≥3
+  named classes or patterns recur in the session's decisions.
+- **§10 Cycle history.** Review cycles run, findings (BLOCKING / IMPORTANT /
+  MINOR counts), fold record, verify-before-fold spot-checks. **OMIT
+  criterion:** OMIT when the snapshot is written before any review cycle has
+  run. **REQUIRED criterion:** required after the first dual-review cycle
+  closes.
+- **§11 Pipeline state.** DAG of artifacts (brainstorm → plan → impl → review)
+  with current cursor position. ASCII tree or table.
+- **§12 Pre-restart artifacts.** Manifest table: each durable artifact's path +
+  status. Lets restart-you spot-check all artifacts exist before acting.
+- **§13 Anticipated Q&A.** Pre-answer questions restart-you or downstream
+  implementer will ask. Format: Q (bold) + A (short). Answers cite live code so
+  downstream agents don't re-derive.
+- **§14 References.** Load-bearing index: bd IDs (with one-line state), commit
+  anchors (with SHA + one-line claim), memory keys (with rationale for
+  relevance), file paths grouped by purpose, critical message IDs (for
+  transcript reconstruction).
+- **§15 Honest unknowns.** List facts you suspect changed during the session OR
+  were never confirmed. Future-you must NOT carry these forward as truth until
+  verified.
+- **§16 Restart-you's immediate next actions.** Numbered. Step 1 actionable from
+  cold start.
+
+**Visual-drift note:** Extended template adopts `§N.` prefix convention
+intentionally distinct from standard's `N. **Header**`
+numbered-list-with-bold-lead. The divergence signals grade difference (standard
+= compact, extended = comprehensive). Do NOT align them; the two surfaces stay
+visually distinct on purpose. **Fallback** (Tier 2): if any runtime strips `§`
+characters during rendering or commit-message embedding, the variant skill MAY
+substitute bold-numbered (`**1.**`, `**2.**`, …) matching standard.
+
+## Step 3 — Write the continuation directly to your restart file
+
+Use your Write tool to save the composed continuation to:
+
+```text
+${REPO}/.thrum/restart/${AGENT}.md
+```
+
+`thrum prime` will auto-inject this file at next session start (whether wake
+comes from `thrum tmux restart` or `thrum tmux create`). No bash heredoc or
+`cat <<EOF` redirection is needed — write the file directly.
+
+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

@@ -0,0 +1,112 @@
+---
+description:
+  Shared Authored-against stamp protocol — canonical format, derivation
+  commands, and never-type rule. Not user-invocable directly.
+---
+
+# Authored-against Stamp Protocol (shared partial)
+
+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/`
+— a hand-listed consumer roster in this file would rot the moment a new emitter or
+reader is added, so none is kept here.)
+
+## Purpose
+
+A date alone cannot tell a reader whether the tree moved since an artifact was
+authored. The Authored-against stamp embeds the exact commit SHA the author was
+looking at and the configured merge target at authoring time. A reader can later
+run the stamped diff command to detect whether any cited file has changed —
+converting a qualitative suspicion ("is this stale?") into a falsifiable check.
+
+## Stamp format (emitted artifact — verbatim)
+
+Place these two lines at the appropriate location in the artifact (immediately
+after its own date/frontmatter for brainstorm/plan/prompt; immediately after the
+`Last updated` line for State.md and project_state.md):
+
+```text
+**Authored-against:** `<sha>` target: `<merge_target>`
+
+> ⚠️ Verify base before acting: `git diff <sha>..origin/<merge_target> -- <files cited>` -- non-empty ⇒ cited code moved. (Resolve `<merge_target>` through its remote-tracking ref, never a bare local branch name — a local branch of the same name can be stale or absent.)
+```
+
+Always resolve `<merge_target>` through its remote-tracking ref
+(`origin/<merge_target>`), never a bare local branch name, in every recipe in
+this file — a local branch of the same name can be stale (last fetched days
+ago) or simply absent on the reader's machine, while `origin/<merge_target>`
+is only ever what's actually on the remote. Fetch before running any of these
+diffs if the remote-tracking ref might be stale.
+
+## Derivation commands (run at authoring time)
+
+```bash
+# SHA of the current HEAD
+git rev-parse HEAD
+
+# Configured merge target
+jq -r '.orchestration.merge_target' .thrum/config.json
+```
+
+The author must never type or remember either value by hand — both come from the
+shell commands above, run at authoring time.
+
+If either command returns empty or `null`, STOP and report — do NOT emit a stamp
+with a null/empty field. An artifact with no stamp is honest; an artifact stamped
+`null` is a lie the reader cannot detect (the string "null" still matches the
+reader's regex, so it reads as a valid stamp instead of UNVERIFIABLE, and the
+resulting `git diff <sha>..null` then errors).
+
+Before emitting the stamp, also verify the derived `<sha>` actually resolves:
+
+```bash
+git cat-file -e <sha>
+# or: git rev-parse --verify <sha>^{commit}
+```
+
+If this fails, STOP and report — do NOT emit a stamp citing an unresolvable SHA.
+This is the same failure class as the null/empty check above (a stamp the
+reader cannot trust), catching a different way to get there: `git rev-parse
+HEAD` itself can't produce a bad SHA, but a stamp isn't always freshly derived
+this way — it can be hand-typed, copied from a stale source, or otherwise
+introduced without running the command above. Treat this resolve-check as a
+mandatory guard regardless of how the SHA was obtained, not an optional sanity
+check.
+
+## Format conventions
+
+The stamp follows the same literal-match convention as the `THRUM-REVIEW` marker
+(canonical form documented in `coordinator-running-brainstorm-cycles` skill
+§ "Footer → commit → stamp"): fixed field order, case-sensitive, ASCII-only —
+parseable with `grep -F` semantics without regex. The reader-side regex in
+`verify-against-plan` anchors on this fixed format; do not reorder or recase any
+field.
+
+## Read-time provenance re-derivation
+
+Both checks below are computable from the two fields the stamp already carries
+(`<sha>` and `<merge_target>`) — no new stamped field is needed. A reader running
+either check for the first time, or re-running it on an artifact read before,
+must run them in this exact order; the second is undefined if the first fails
+(short-circuit):
+
+1. **SHA-resolves** — `git cat-file -e <sha>` (or
+   `git rev-parse --verify <sha>^{commit}`). If this fails, the stamp cites a
+   FABRICATED or mistyped SHA — flag RED immediately and do NOT attempt check 2.
+   Merge-status has no defined answer for a SHA that does not exist.
+
+2. **Merge-status** — only once check 1 has passed:
+   `git merge-base --is-ancestor <sha> origin/<merge_target>`. If this succeeds
+   (the SHA IS already an ancestor of the merge target) AND the artifact's own
+   prose describes that SHA's work as still open ("in-progress", "awaiting a
+   gate", "not yet merged", or similar), flag the claim STALE — the work
+   described has already landed; whatever gate the artifact was waiting on
+   already happened, or was never blocking to begin with.
+
+This re-derivation must run EVERY TIME the artifact is read, not only once at
+authoring time — the same diff-at-read discipline this file already establishes
+for the base stamp (`git diff <sha>..origin/<merge_target>`). A check that only
+ran once at write time cannot catch drift that accumulates afterward, as the
+tree keeps moving.

package/assets/commands/thrum-_verify-before-write-protocol.md

@@ -0,0 +1,27 @@
+---
+description:
+  Shared "Verify before you write" invariant consumed by state-writing
+  skills. Not user-invocable directly.
+---
+
+# Verify Before You Write Protocol (shared partial)
+
+Consumers: run `grep -rl _verify-before-write-protocol claude-plugin/skills/`
+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
+skill is added or dropped.
+
+A written fact is TRUE at the moment it's recorded and can silently become
+FALSE later — the reader can't tell, because a note doesn't present itself as
+a time-bound claim. Before writing anything:
+
+- Only write what you've verified against current state — not what you
+  remember, assume, or were told once.
+- A note recording an UNEXPLAINED artifact must carry the unexplained-ness
+  forward — "not mine, cause unknown, nobody has traced this" — rather than
+  resolving it to a disposition like "ignore it." The note isn't wrong to cope
+  with noise you can't act on; the defect is closing the question when
+  nothing is actually known. "Ignore it" is unfalsifiable by construction —
+  an instruction to not look can't be caught by looking, because diligence is
+  exactly what it switches off — and it can silently train every future
+  session to stop looking at the one visible symptom of a live bug.

package/assets/commands/thrum-inbox.md

@@ -0,0 +1,22 @@
+---
+description: Check message inbox
+---
+
+List messages in your inbox. Messages are auto-marked as read when displayed.
+
+```bash
+thrum inbox                  # All recent messages (auto-marks as read)
+thrum inbox --unread         # Unread only (does not mark as read)
+thrum inbox --json           # Machine-readable
+thrum sent --unread          # Check sent items with unread recipients
+thrum message read --all     # Mark all messages as read
+```
+
+**Search — do not page through it.** The default page is 10, newest-first, so
+stale unread sorts LAST exactly when it has been waiting longest.
+
+```bash
+thrum message search "<term>"      # full-text across all messages
+thrum inbox -q "<term>"            # same full-text search, scoped to your inbox
+thrum message reindex              # rebuild the FTS index if search looks wrong
+```

package/assets/commands/thrum-load-context.md

@@ -0,0 +1,17 @@
+---
+description:
+  Restore saved agent work context after compaction or session restart
+---
+
+Run `thrum prime` to restore your complete session context. Prime now includes
+project state and session context inline — no separate load step needed.
+
+```bash
+thrum prime
+```
+
+If you need only the session context (without the full briefing):
+
+```bash
+thrum context show --session
+```

package/assets/commands/thrum-overview.md

@@ -0,0 +1,17 @@
+---
+description: Combines identity, team, inbox, and sync status
+---
+
+Show a combined view of agent identity, active team members, inbox messages, and
+sync status.
+
+```bash
+thrum overview               # Human-readable
+thrum overview --json        # Machine-readable
+```
+
+This is equivalent to running `thrum team`, `thrum inbox`, `thrum sent`, and
+`thrum sync status` together.
+
+`thrum inbox` here shows only the default page — see `/inbox` for the paging
+caveat and full-text search.

package/assets/commands/thrum-prime.md

@@ -0,0 +1,30 @@
+---
+description: Load AI-optimized session context
+---
+
+Run `thrum prime` to load your complete session briefing — identity, daemon
+health, role instructions, project state, and session context (plus messaging
+protocol if multi-agent mode).
+
+```bash
+thrum prime
+```
+
+Use `thrum prime --json` for structured output.
+
+## First turn: emit a one-line ack
+
+After loading the briefing, your very first action of this turn — before running
+any tools or further reading — is to print one plain-text line in this format:
+
+```text
+@<agent-name> primed (<role>/<module>). <one-sentence intent>. Standing by.
+```
+
+Substitute the fields from your own identity (visible at the top of the
+briefing) and write `<intent>` as a brief sentence drawn from your inbox or
+restart snapshot. Drop the `/<module>` segment when no module is set or it
+matches the role.
+
+This produces visible scrollback so humans can distinguish a healthy launch from
+a stuck or failed one without probing the daemon.

package/assets/commands/thrum-quickstart.md

@@ -0,0 +1,14 @@
+---
+description: Register agent and start session
+---
+
+Register as an agent, start a session, and set intent in one step.
+
+If arguments are provided, use them. Otherwise ask the user for role, module,
+and intent.
+
+```bash
+thrum quickstart --name <agent-name> --role <role> --module <module> --intent "<description>"
+```
+
+Common roles: `implementer`, `planner`, `reviewer`, `tester`, `coordinator`.

package/assets/commands/thrum-reply.md

@@ -0,0 +1,28 @@
+---
+description: Reply to a message
+---
+
+Reply to a message with the same audience as the original.
+
+If arguments are provided, use them. Otherwise ask for the message ID and reply
+content.
+
+```bash
+thrum reply <msg-id> --stdin <<'EOF'
+response text
+EOF
+```
+
+The reply inherits the original message's audience (direct or group).
+
+If the body has backticks, `$(...)`, `$VAR`, or quotes, pass it via a quoted
+heredoc so the shell doesn't corrupt it:
+
+```bash
+thrum reply <msg-id> --stdin <<'EOF'
+Done — see `internal/foo.go`. Cost was $(estimate).
+EOF
+```
+
+`--body-file <path>` reads from a file; the response argument `-` is a stdin
+alias.