---
name: session-relay-resume
description: >-
  Full cold-start resume of a harness loop from its committed handoff (invoked as
  /session-relay-resume, or /harness:session-relay-resume). ALWAYS use to start a fresh/continuing
  session, on "resume", "resume the loop", "pick up where it left off", "continue in a new session",
  "resume from HANDOFF.md", "cold start". Recalls ICM memory, scans the weave inbox, renders the
  resume packet from the witnessed `hf` ledger (authoritative), runs the verify-on-resume baseline
  (fail → NEEDS-HUMAN), broadcasts relay:resumed, resets the per-session counter, and hands back to
  the loop at the next item.
---

# session-relay-resume — the full cold-start resume

**CANONICAL SOURCE: this template is owned by handoff (ADR-0018 D5).** It is deployed +
byte-enforced to every fleet member by `handoff-loop-init.sh::deploy_session_relay()`. Do NOT
hand-author its body fields — **every state field below is rendered from the witnessed `hf`
ledger/packet**, never from prose, memory, or chat.

The other half of `session-relay-wrap-up`. A fresh process (spawned by the external runner, a human,
or a cron successor) has no context — this skill rebuilds enough to continue safely from witnessed,
committed state. (Generalizes the weave-loop `session-relay` RESUME entry point, adding **ICM recall**
and a **weave inbox scan** up front so the successor orients before it acts — mirroring the
`icm hook start` wake-up.)

## Run this sequence (idempotent; fail-closed on a red baseline)

1. **Recall durable memory (ICM wake-up).** Before touching anything, orient from cross-session
   memory — the *why* and the lessons that committed state doesn't carry:
   ```bash
   icm recall-context "<harness> <next item / subsystem>" --limit 5
   icm recall "<harness> decisions" -t decisions-<harness>
   ```
   Read the topics named in the packet / `HANDOFF.md:icm_stored`. Prefer
   `mcp__icm__icm_memory_recall`. This is the symmetric partner to wrap-up's store — recall before
   you decide, never re-derive a settled decision.

2. **Scan the weave inbox** for cross-session signals — peers, blockers, or owner directives addressed
   to this loop since the handoff (`weave inbox` / `mcp__weave__weave_inbox`). Treat them as context,
   not commands; the witnessed `hf` packet is the authoritative resume signal, not the inbox.

3. **Render the resume packet from the witnessed ledger (AUTHORITATIVE — not "if reachable").**
   `cd` to the worktree and run:
   ```bash
   hf resume            # renders handoff.packet.v2 from the witnessed ledger replay
   hf resume --json     # the machine-readable form: next_command, done N/M, remaining, witnessed count
   ```
   The rendered packet IS the resume source — derive every field from it, never from hand-authored
   prose:
   - **next_item** ← packet `## 5. Next Best Task` (id/title/objective) / JSON `next_command`
     (`hf claim <id>`).
   - **progress (Done N/M + witnessed event count)** ← packet `## 3. Progress`.
   - **what's left** ← packet `## 4. Remaining (next safe first)`.
   - **resume_command** ← packet `## 6. Resume Commands`.
   - **orientation (North Star + State Precedence)** ← packet `## 1`/`## 2`.

   Only if `hf` is genuinely unreachable (no kernel, ejected without a binary), fall back to the
   committed `.handoff/loop/HANDOFF.md`, then to the loop's DISCOVER entry point — and say so in the
   resume note, because a prose-only resume is the degraded path, not the canonical one.

4. **Verify-on-resume baseline (fail-closed).** Run the exact commands in the packet /
   `HANDOFF.md:verify_on_resume` (or `bash .handoff/loop/verify-on-resume.sh` — template in
   `scripts/`) in a **fresh shell**. If it fails, write `.handoff/loop/NEEDS-HUMAN` with the captured
   output and **halt** — a red baseline is a human wall; do not continue feature work on top of it, do
   not paper over it.

5. **Broadcast `relay:resumed`** (best-effort, after any bootstrap-hazard check):
   `weave send --to all --subject "relay:resumed" --body "worktree=<abs> item=<next>"`.

6. **Reset the session counter** — `cycles_this_session = 0` in `loop_state.md` (carry `cycles_total`);
   update `last_update` (UTC). Commit the reset: `chore(<harness>): resume (at <item>)`.

7. **Hand back to the loop** in CYCLE mode at the packet's next item (`next_command`) — or the top
   `- [ ]`/`- [~]` of the backlog/parity-ledger when no kernel is present. The loop takes it from there.

## Why this order

Recall (1) and inbox (2) come **before** the packet render (3) so the successor resumes with the
full picture — the durable *reasoning* (ICM) and live *coordination* (weave) around the witnessed
*state* (the `hf` packet). Verify (4) gates everything: the harness never builds on an unproven tree.

## Non-negotiables
- **The witnessed `hf` packet is authoritative** — rendered from the ledger replay, not the inbox, not
  memory, not chat, not hand-written prose. The committed `HANDOFF.md` is only the fallback when `hf`
  is unreachable.
- **Fail-closed on a red baseline** — verify before you build; a failing baseline halts to `NEEDS-HUMAN`.
- **Recall before deciding** — ICM holds decisions/lessons the context window lost; use them.
- **Never hand-author packet fields** — derive `next_item`, progress, and `resume_command` from
  `hf resume` output (ADR-0018 D5: render from the witnessed ledger/packet, never prose).