Add a runtime-continuity / state-handoff skill for crash-resume boundaries

Missing topic

The current corpus has strong coverage for filesystem-context, context-compression, multi-agent-patterns, memory-systems, and harness-engineering, but I do not see a focused skill for runtime continuity / crash-resume state.

This is showing up as agent workflows move from short chats to long pipelines, background agents, desktop execution, and scheduled loops. The failure mode is not only "the agent forgot context". It is: a run stops, crashes, compacts, or hands off, and the next actor cannot tell what state is safe to resume from.

Proposed skill boundary

Name candidate: runtime-continuity or state-handoff.

Activate when the task involves:

• resuming after crash/compact/sleep/wake
• long-running coding loops or background agents
• handing work between agents/tools/sessions
• deciding whether to continue the current state or restart from a packet
• making review cheaper than reconstructing a conversation

Do not activate for:

• general memory architecture: memory-systems
• just moving context into files: filesystem-context
• broad autonomous-loop design: harness-engineering
• generic compression strategy: context-compression

Core mechanism

Teach agents to persist a resume packet before the state boundary, not a transcript summary after the fact.

Minimal packet shape:

objective: what the run is trying to finish
repo_ref: branch/commit/worktree or equivalent environment identity
dirty_state: changed files + whether edits are committed/stashed
scope: files/systems intentionally in scope
skipped: files/systems intentionally not inspected
last_action: command/tool/edit just performed
verifier: exact check to rerun + last result
open_risks: assumptions still unproven
next_safe_step: one action that is safe from this packet alone
exit_condition: when the loop/session should stop or ask a human

The important distinction: a memory record says what the agent learned; a resume packet says what another run can safely do next.

Why it seems separate from existing skills

filesystem-context covers durable files and just-in-time discovery. harness-engineering covers loops, logs, rollback, novelty gates and approvals. This missing slice is narrower: the state contract at a discontinuity boundary.

A good skill would give agents a rule like:

If the next iteration cannot restart from the packet, it is not a safe loop; it is an extended session wearing a scheduler costume.

Possible example

Before:

"Continue where we left off. The tests were failing but I think the auth refactor is almost done."

After:

objective: finish auth-session refactor without changing public token format
repo_ref: feature/auth-session-split @ abc1234, dirty worktree
scope: src/auth/session.ts, src/auth/token.ts, tests/auth/session.test.ts
skipped: billing auth checks, oauth provider adapters
last_action: changed session parser to reject missing expiresAt
verifier: npm test -- tests/auth/session.test.ts (failed: 2 token-format snapshots)
open_risks: not yet checked oauth adapter assumptions
next_safe_step: inspect failed snapshots before editing token serializer
exit_condition: stop if serializer change touches public token format

This would complement the existing corpus without requiring vendor-specific behavior.