opencode-thrum-pro 0.1.5 → 0.1.7

package/assets/commands/thrum-inbox.md

@@ -9,7 +9,7 @@ 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
+thrum message read --all --force  # Mark ALL unread as read (run `read --all` alone first — dry run)
 ```
 
 **Search — do not page through it.** The default page is 10, newest-first, so

package/assets/commands/thrum-restart-extended.md

@@ -34,12 +34,16 @@ artifact alone.
 
 ```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` or `git rev-parse --show-toplevel`
+# (both cwd-resolved). A cwd-derived pattern could silently
+# resolve to a DIFFERENT agent's worktree, or the main repo. 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"
@@ -50,11 +54,7 @@ mkdir -p "${REPO}/.thrum/restart"
 
 ### 2. Read the shared snapshot-composition partial
 
-Read the partial at the absolute path:
-
-```text
-${REPO}/claude-plugin/commands/_snapshot-protocol.md
-```
+Invoke the /thrum:snapshot-protocol skill and follow it.
 
 It carries the CRITICAL DISCIPLINE block and BOTH the standard 11-section
 structure and the EXTENDED 16-section structure with per-section guidance.
@@ -64,8 +64,36 @@ structure and the EXTENDED 16-section structure with per-section guidance.
 
 ### 3. Write the continuation
 
-Per Step 3 of the partial, use the Write tool to save your composed continuation
-to `${REPO}/.thrum/restart/${AGENT}.md`. `thrum prime` auto-injects this file on
+First run this PREP block (it mints the path and a per-run nonce):
+
+```bash
+# The Bash tool does NOT persist shell state across calls, so this block
+# re-resolves identity itself. Fail closed: no cwd/git fallback.
+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"
+SNAPSHOT="${REPO}/.thrum/restart/${AGENT}.md"
+NONCE="zn6fx-$(date +%s)-$$-${RANDOM}${RANDOM}"
+echo "SNAPSHOT_PATH=${SNAPSHOT}"
+echo "SNAPSHOT_NONCE=${NONCE}"
+```
+
+Write to EXACTLY the printed `SNAPSHOT_PATH` (not a path you re-derive), and make
+sure the file contains the marker below (as its final line), with the printed `SNAPSHOT_NONCE` — verify searches the whole file for it:
+
+```text
+<!-- snapshot-nonce: <SNAPSHOT_NONCE> -->
+```
+
+**Record both values** — the verify step pastes them into its verify block, which
+fails closed unless the file at that exact path carries that nonce.
+
+Then, per Step 3 of the partial, use the Write tool to save your composed
+continuation to that exact path. `thrum prime` auto-injects this file on
 next session start regardless of whether wake comes from `thrum tmux restart` or
 operator-initiated `thrum tmux create`.
 
@@ -91,13 +119,44 @@ to preserve — strictly worse than idling. Verify the EFFECT, not the action: a
 vague "I wrote it" is not verification; check the FILE.
 
 ```bash
-SNAPSHOT="${REPO}/.thrum/restart/${AGENT}.md"
+SNAPSHOT="<PASTE SNAPSHOT_PATH FROM STEP 3>"
+NONCE="<PASTE SNAPSHOT_NONCE FROM STEP 3>"
+# Fresh authoritative re-resolution (shell state does NOT persist across Bash
+# calls); it must agree with the path you actually wrote in Step 3.
+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 verifying the wrong repo's snapshot. 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; }
+SESSION_RAW=$(thrum whoami --field tmux_session)
+SESSION=${SESSION_RAW%%:*}
+EXPECTED="${REPO}/.thrum/restart/${AGENT}.md"
+BIND_OK=1
+if [ -z "$SNAPSHOT" ] || [ -z "$NONCE" ] || [[ "$SNAPSHOT$NONCE" == *"<PASTE"* ]]; then
+  echo "VERIFY FAILED: SNAPSHOT/NONCE not filled in — paste SNAPSHOT_PATH and SNAPSHOT_NONCE from Step 3. SNAPSHOT_OK=0"; BIND_OK=0
+elif [ "$SNAPSHOT" != "$EXPECTED" ]; then
+  echo "VERIFY FAILED: identity/worktree DRIFT between write time and verify time. Written path: $SNAPSHOT — re-resolved path: $EXPECTED. SNAPSHOT_OK=0"; BIND_OK=0
+fi
 NOW=$(date +%s)
-MTIME=$(stat -f %m "$SNAPSHOT" 2>/dev/null || stat -c %Y "$SNAPSHOT" 2>/dev/null)
+# mtime: choose the stat dialect explicitly. GNU `stat -f` means --file-system
+# (succeeds with multiline garbage), so the `stat -f %m || stat -c %Y` one-liner
+# breaks on Linux — branch on which dialect this box speaks.
+if stat -f %m . >/dev/null 2>&1; then
+  MTIME=$(
+    stat -f %m "$SNAPSHOT" 2>/dev/null
+  )
+else
+  MTIME=$(
+    stat -c %Y "$SNAPSHOT" 2>/dev/null
+  )
+fi
 AGE=$(( NOW - ${MTIME:-0} ))
 SNAPSHOT_OK=1
 
-if [ ! -f "$SNAPSHOT" ]; then
+if [ "$BIND_OK" = 0 ]; then
+  SNAPSHOT_OK=0   # binding failure already reported above
+elif [ ! -f "$SNAPSHOT" ]; then
   echo "VERIFY FAILED: no snapshot at $SNAPSHOT"; SNAPSHOT_OK=0
 elif [ ! -s "$SNAPSHOT" ]; then
   echo "VERIFY FAILED: snapshot at $SNAPSHOT is empty"; SNAPSHOT_OK=0
@@ -105,6 +164,8 @@ elif [ ! -r "$SNAPSHOT" ]; then
   echo "VERIFY FAILED: snapshot at $SNAPSHOT is not readable"; SNAPSHOT_OK=0
 elif [ "$AGE" -gt 300 ]; then
   echo "VERIFY FAILED: snapshot at $SNAPSHOT is ${AGE}s old — stale (from a prior restart), not this session's write"; SNAPSHOT_OK=0
+elif ! grep -qF -- "$NONCE" "$SNAPSHOT"; then
+  echo "VERIFY FAILED: nonce not found in $SNAPSHOT — file at that path is not this session's write"; SNAPSHOT_OK=0
 else
   echo "VERIFY OK: snapshot exists, non-empty, readable, written ${AGE}s ago"
 fi
@@ -120,8 +181,16 @@ else
   echo "VERIFY FAILED: tmux session '$SESSION' (stripped from '$SESSION_RAW') does not resolve to a live tmux session"
   SESSION_OK=0
 fi
+echo "SNAPSHOT_OK=${SNAPSHOT_OK} SESSION_OK=${SESSION_OK}"
 ```
 
+**Fail-closed binding rule:** the block passes only for the exact path and nonce
+the Step 3 PREP block printed (paste them into its first two lines). Empty or
+placeholder values, identity/worktree drift between write and verify time, or a
+file at that path without the nonce all mean VERIFY FAILED — a fresh file merely
+sitting at the re-derived path is NOT proof you wrote it. Use the
+`SNAPSHOT_OK`/`SESSION_OK` values it prints in Step 6.
+
 **"Properly" means, explicitly:** snapshot exists at your OWN worktree's
 `.thrum/restart/<your-agent-id>.md`, non-empty, readable, AND recently written
 by Step 3 of THIS session (not a leftover from a previous restart that Step 3

package/assets/commands/thrum-restart.md

@@ -15,12 +15,17 @@ orchestrate the handoff.
 
 ```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` or `git rev-parse --show-toplevel`
+# (both 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"
@@ -65,7 +70,7 @@ 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
@@ -130,12 +135,36 @@ always be present so future-you can scan for what's covered and what isn't.
 
 ### 3. Write the continuation directly to your restart file
 
-Use your Write tool to save the composed continuation to:
+First run this PREP block (it mints the path and a per-run nonce):
+
+```bash
+# The Bash tool does NOT persist shell state across calls, so this block
+# re-resolves identity itself. Fail closed: no cwd/git fallback.
+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"
+SNAPSHOT="${REPO}/.thrum/restart/${AGENT}.md"
+NONCE="zn6fx-$(date +%s)-$$-${RANDOM}${RANDOM}"
+echo "SNAPSHOT_PATH=${SNAPSHOT}"
+echo "SNAPSHOT_NONCE=${NONCE}"
+```
+
+Write to EXACTLY the printed `SNAPSHOT_PATH` (not a path you re-derive), and make
+sure the file contains the marker below (as its final line), with the printed `SNAPSHOT_NONCE` — verify searches the whole file for it:
 
 ```text
-${REPO}/.thrum/restart/${AGENT}.md
+<!-- snapshot-nonce: <SNAPSHOT_NONCE> -->
 ```
 
+**Record both values** — the verify step pastes them into its verify block, which
+fails closed unless the file at that exact path carries that nonce.
+
+Then use your Write tool to save the composed continuation to that exact path.
+
 `thrum prime` will auto-inject this file at next session start. No bash heredoc
 or `cat <<EOF` redirection is needed — write the file directly.
 
@@ -161,13 +190,44 @@ to preserve — strictly worse than idling. Verify the EFFECT, not the action: a
 vague "I wrote it" is not verification; check the FILE.
 
 ```bash
-SNAPSHOT="${REPO}/.thrum/restart/${AGENT}.md"
+SNAPSHOT="<PASTE SNAPSHOT_PATH FROM STEP 3>"
+NONCE="<PASTE SNAPSHOT_NONCE FROM STEP 3>"
+# Fresh authoritative re-resolution (shell state does NOT persist across Bash
+# calls); it must agree with the path you actually wrote in Step 3.
+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 verifying the wrong repo's snapshot. 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; }
+SESSION_RAW=$(thrum whoami --field tmux_session)
+SESSION=${SESSION_RAW%%:*}
+EXPECTED="${REPO}/.thrum/restart/${AGENT}.md"
+BIND_OK=1
+if [ -z "$SNAPSHOT" ] || [ -z "$NONCE" ] || [[ "$SNAPSHOT$NONCE" == *"<PASTE"* ]]; then
+  echo "VERIFY FAILED: SNAPSHOT/NONCE not filled in — paste SNAPSHOT_PATH and SNAPSHOT_NONCE from Step 3. SNAPSHOT_OK=0"; BIND_OK=0
+elif [ "$SNAPSHOT" != "$EXPECTED" ]; then
+  echo "VERIFY FAILED: identity/worktree DRIFT between write time and verify time. Written path: $SNAPSHOT — re-resolved path: $EXPECTED. SNAPSHOT_OK=0"; BIND_OK=0
+fi
 NOW=$(date +%s)
-MTIME=$(stat -f %m "$SNAPSHOT" 2>/dev/null || stat -c %Y "$SNAPSHOT" 2>/dev/null)
+# mtime: choose the stat dialect explicitly. GNU `stat -f` means --file-system
+# (succeeds with multiline garbage), so the `stat -f %m || stat -c %Y` one-liner
+# breaks on Linux — branch on which dialect this box speaks.
+if stat -f %m . >/dev/null 2>&1; then
+  MTIME=$(
+    stat -f %m "$SNAPSHOT" 2>/dev/null
+  )
+else
+  MTIME=$(
+    stat -c %Y "$SNAPSHOT" 2>/dev/null
+  )
+fi
 AGE=$(( NOW - ${MTIME:-0} ))
 SNAPSHOT_OK=1
 
-if [ ! -f "$SNAPSHOT" ]; then
+if [ "$BIND_OK" = 0 ]; then
+  SNAPSHOT_OK=0   # binding failure already reported above
+elif [ ! -f "$SNAPSHOT" ]; then
   echo "VERIFY FAILED: no snapshot at $SNAPSHOT"; SNAPSHOT_OK=0
 elif [ ! -s "$SNAPSHOT" ]; then
   echo "VERIFY FAILED: snapshot at $SNAPSHOT is empty"; SNAPSHOT_OK=0
@@ -175,6 +235,8 @@ elif [ ! -r "$SNAPSHOT" ]; then
   echo "VERIFY FAILED: snapshot at $SNAPSHOT is not readable"; SNAPSHOT_OK=0
 elif [ "$AGE" -gt 300 ]; then
   echo "VERIFY FAILED: snapshot at $SNAPSHOT is ${AGE}s old — stale (from a prior restart), not this session's write"; SNAPSHOT_OK=0
+elif ! grep -qF -- "$NONCE" "$SNAPSHOT"; then
+  echo "VERIFY FAILED: nonce not found in $SNAPSHOT — file at that path is not this session's write"; SNAPSHOT_OK=0
 else
   echo "VERIFY OK: snapshot exists, non-empty, readable, written ${AGE}s ago"
 fi
@@ -190,8 +252,16 @@ else
   echo "VERIFY FAILED: tmux session '$SESSION' (stripped from '$SESSION_RAW') does not resolve to a live tmux session"
   SESSION_OK=0
 fi
+echo "SNAPSHOT_OK=${SNAPSHOT_OK} SESSION_OK=${SESSION_OK}"
 ```
 
+**Fail-closed binding rule:** the block passes only for the exact path and nonce
+the Step 3 PREP block printed (paste them into its first two lines). Empty or
+placeholder values, identity/worktree drift between write and verify time, or a
+file at that path without the nonce all mean VERIFY FAILED — a fresh file merely
+sitting at the re-derived path is NOT proof you wrote it. Use the
+`SNAPSHOT_OK`/`SESSION_OK` values it prints in Step 6.
+
 **"Properly" means, explicitly:** snapshot exists at your OWN worktree's
 `.thrum/restart/<your-agent-id>.md`, non-empty, readable, AND recently written
 by Step 3 of THIS session (not a leftover from a previous restart that Step 3
@@ -267,9 +337,17 @@ the operator:
 
 ## After Restart: Session Archive
 
-After restart, your snapshot doesn't disappear — it moves to
+After restart, IF you saved a snapshot within the graceful window, it moves to
 `.thrum/agents/<your-agent-id>/sessions/` and stays there as a persistent log
-entry. Browse the archive with:
+entry. If the graceful save window elapsed before you saved (e.g. you were
+mid-task and missed the interrupt), the daemon writes NO snapshot and records
+a `.timeout-marker` sibling file instead — `thrum tmux restart` reports this
+via `snapshot_outcome: timeout` (CLI shows a 🔴 warning) rather than silently
+looking like success. Do not infer success from an empty `.thrum/restart/`
+directory alone — an empty source directory is consistent with either a
+genuine successful archive OR a bug that resolved to the wrong destination,
+silently aliased another agent's archive, or wrote truncated content. Browse
+the archive with:
 
 ```bash
 thrum agent sessions list                    # default: this agent
@@ -278,6 +356,20 @@ thrum agent sessions list --json             # NDJSON for scripts
 thrum agent sessions list --all              # every agent, grouped
 ```
 
+**Verify the RESOLVED DESTINATION's identity, not just its existence.**
+Every archive already self-verifies: `sessionarchive.Archive` computes a
+SHA-256 checksum of the snapshot content it read *before* the move, then
+re-reads the file it just wrote at the destination and confirms the
+checksums match (`sessionarchive.VerifyArchivedIdentity` /
+`ChecksumContent` — see `internal/daemon/sessionarchive/verify.go`) before
+reporting success. A destination that exists but doesn't hash-match its
+own pre-move content is treated as a hard failure of the archive call, not
+a warning. This is what actually proves "the file at
+`.thrum/agents/<id>/sessions/<ts>-restart.md` IS the artifact that was
+captured," as opposed to merely "a file with a plausible name is sitting
+there" — the latter is what `thrum agent sessions list`'s presence-only
+view alone would let you assume.
+
 Permissions are user-only (`0600` for each snapshot file, `0700` for the
 sessions folder). Operators on multi-user machines must copy explicitly to share
 archives with another account.

package/assets/commands/thrum-send.md

@@ -11,7 +11,7 @@ content.
 thrum send --to @agent_name --stdin <<'EOF'       # Direct message (quoted heredoc body)
 message here
 EOF
-thrum send --to @everyone --stdin <<'EOF'         # Broadcast to all agents
+thrum send --to @agent_a --to @agent_b --stdin <<'EOF'   # Multiple explicit recipients
 message here
 EOF
 ```
@@ -19,6 +19,9 @@ EOF
 Unknown recipients are a hard error. Use `thrum team` to verify agent names
 before sending.
 
+`@everyone` was removed by design (P0 ruling); do not restore it — name
+every recipient explicitly, or address a scoped agent-type group.
+
 If the body has backticks, `$(...)`, `$VAR`, or quotes, pass it via a quoted
 heredoc so the shell doesn't corrupt it:
 

package/assets/commands/thrum-sleep-extended.md

@@ -30,12 +30,16 @@ to sleep until the operator wakes it later. Same termination semantics as
 ```bash
 # Resolve identity + your worktree (needed before reading the partial).
 # $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` or `git rev-parse --show-toplevel`
+# (both cwd-resolved). A cwd-derived pattern could silently
+# resolve to a DIFFERENT agent's worktree, or the main repo. 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"
@@ -54,11 +58,7 @@ no session end. Exit code 1.
 
 ### 2. Read the shared snapshot-composition partial
 
-Read the partial at the absolute path:
-
-```text
-${REPO}/claude-plugin/commands/_snapshot-protocol.md
-```
+Invoke the /thrum:snapshot-protocol skill and follow it.
 
 Apply its Step 2 (compose your continuation) per the structure guidance.
 
@@ -76,44 +76,43 @@ Per Step 3 of the partial, use the Write tool to save your composed continuation
 to `${REPO}/.thrum/restart/${AGENT}.md`. On next boot, `thrum prime`
 auto-injects this file — same mechanism as restart wake.
 
-### 4. Back up important files to your durable agents folder (survives worktree teardown)
+### 4. Back up OTHER important artifacts to your durable agents folder (survives worktree teardown)
 
-**Your worktree may be torn down while you sleep — and if it is, YOUR SNAPSHOT
-GOES WITH IT unless you do this step.**
+**Your restart snapshot itself no longer needs this step.** Step 6
+(`thrum agent sleep`) now relocates `<worktree>/.thrum/restart/<agent-id>.md`
+to the canonical `<main-repo>/.thrum/agents/<agent-id>/sessions/<ts>-restart.md`
+synchronously, BEFORE it kills your pane — that is the fix for the bug this
+step used to exist to work around (the snapshot previously was archived only
+at your NEXT WAKE, so a worktree reap between sleep and wake destroyed it
+permanently with no warning).
 
 🔴 **READ THIS CAREFULLY.** A worktree's `.thrum/` is a REAL LOCAL DIRECTORY. The
 `redirect` inside it is just a plain text FILE containing a path — a pointer
 thrum's code consults. The filesystem redirects nothing. Your worktree keeps its
 own local `agents/`, `context/`, `identities/`, and `restart/`.
 
-**THE ACTUAL MECHANISM:** your snapshot at `<worktree>/.thrum/restart/<agent-id>.md`
-is **worktree-local**. It is copied into the main repo **only when you WAKE** —
-`thrum prime` reads it from the worktree and archives it to
-`<main-repo>/.thrum/agents/<agent-id>/sessions/`. **Then and only then.** So a
-teardown that happens BEFORE your wake destroys the snapshot, permanently, and
-nothing warns you. This matters more for an extended snapshot: you are parking
-wire contracts, a capability matrix, and design rationale that are expensive to
-reconstruct and exist nowhere else.
-
-**Leave the snapshot where it is** — `thrum prime` reads it from the worktree on
-wake, so that path is correct and required. **Additionally**, copy anything you
-need to survive teardown to the MAIN REPO PATH, resolved explicitly:
+**What THIS step is still for:** anything OTHER than the restart snapshot that
+you need to survive a worktree teardown while parked — reports / findings you
+authored, important uncommitted artifacts, and anything your resume plan
+references. This matters more for an extended snapshot: you are parking wire
+contracts, a capability matrix, and design rationale that are expensive to
+reconstruct and exist nowhere else — but that content lives IN the snapshot
+itself, which Step 6 already relocates; use this step for anything ELSE.
+Copy those to the MAIN REPO PATH, resolved explicitly:
 
 ```bash
 # Resolve the main repo's .thrum from the redirect FILE (do not assume a path).
-MAIN_THRUM=$(cat "${REPO}/.thrum/redirect" 2>/dev/null) || MAIN_THRUM="${REPO}/.thrum"
+MAIN_THRUM=$(
+  cat "${REPO}/.thrum/redirect" 2>/dev/null
+) || MAIN_THRUM="${REPO}/.thrum"
 mkdir -p "${MAIN_THRUM}/agents/${AGENT}"
-cp "${REPO}/.thrum/restart/${AGENT}.md" "${MAIN_THRUM}/agents/${AGENT}/last-sleep-snapshot.md"
-# ...and any other artifact you need on wake.
-ls -la "${MAIN_THRUM}/agents/${AGENT}/last-sleep-snapshot.md"   # VERIFY IT LANDED
+cp <artifact> "${MAIN_THRUM}/agents/${AGENT}/<name>"
+ls -la "${MAIN_THRUM}/agents/${AGENT}/<name>"   # VERIFY IT LANDED
 ```
 
-Copy there: reports / findings you authored, important uncommitted artifacts, and
-anything your resume plan references.
-
-**VERIFY THE COPY EXISTS AT THE MAIN PATH before ending your session.** Do not
-trust `cp`'s exit code — list the destination file. This step is your ONLY
-recoverability guarantee against teardown-while-asleep; the redirect is not one.
+If you have nothing beyond the restart snapshot to preserve, this step is a
+no-op — proceed to Step 5. Do not trust `cp`'s exit code for anything you do
+copy — list the destination file to confirm it landed.
 
 ### 5. Mark agent operational status idle
 
@@ -121,29 +120,47 @@ recoverability guarantee against teardown-while-asleep; the redirect is not one.
 thrum agent set-status idle
 ```
 
-`idle` is the signal that this agent has parked. NO new "sleeping" state was
-added — `idle` covers both "no active work" and "parked for operator wake."
+`idle` is the operational/presence-status signal, separate from the durable
+`agents.phase` field. Step 6 (`thrum agent sleep`) is what transitions phase
+to `sleeping` — a real, distinct phase, not folded into `idle`. This step
+only covers the lighter-weight status field.
 
 If `thrum agent set-status` returns an error, continue to Step 6 — the snapshot
 on disk is the load-bearing artifact.
 
-### 6. End session cleanly
-
-```bash
-thrum session end
-```
-
-This emits `agent.session.end` cleanly so the dead-agent sweeper does NOT treat
-the disconnect as a crash.
-
-### 7. Kill own tmux session
+### 6. Sleep the agent (relocate snapshot, teardown, phase transition)
 
 ```bash
-thrum tmux kill "$SESSION"
+thrum agent sleep --agent "$AGENT"
 ```
 
-Tmux pane terminates → runtime process exits → no further activity until
-operator wakes the agent.
+This calls the daemon's `agent.sleep` RPC (CLI alias `park`), which runs the
+full park ceremony in the correct order: it relocates your snapshot from the
+worktree-local `.thrum/restart/` into the canonical
+`agents/<id>/sessions/` directory, *then* kills your own tmux session, *then*
+writes the `agent.phase.transition {to: "sleeping"}` event. This is the fix
+for the bug a raw `thrum session end` + `thrum tmux kill` sequence had: it
+killed the pane before the snapshot was ever relocated (permanent data-loss
+risk if the worktree was reaped first) and left the roster row reading
+`active` after the pane was already gone — a "ghost-active" agent.
+
+**Critical: the daemon kills YOUR OWN pane mid-call, as part of this same
+RPC's teardown stage.** A successful self-park is therefore observed, from
+inside this pane, as the CLI call's transport dying — connection reset, EOF,
+or broken pipe — NOT a clean JSON response; the pane is gone before a
+response can reach it. **Do not retry** `thrum agent sleep` on transport
+loss after dispatch, and **do not treat transport loss as a failure.** It is
+the expected signal that self-park succeeded. A real failure (a gate,
+relocation, or teardown error) is signaled by the RPC returning an explicit
+error message BEFORE the pane dies — that is the only failure signal
+observable from inside this pane. If independent confirmation is needed, it
+must come from a DIFFERENT caller (this pane will be gone) checking
+`thrum agent list` / `thrum team list` afterward.
+
+**Do not fall back to a raw `tmux kill-session`.** A raw kill bypasses
+`agent.sleep`'s relocate-before-kill ordering and daemon bookkeeping
+entirely — reintroducing the exact data-loss and ghost-active bug this
+ceremony exists to close.
 
 ## How wake works