Core

---
name: session-resume
description: Cold-start resume — load all memory and project state to continue any interrupted project
triggers: [resume, continue, new session, where were we, restart project, pick up, interrupted, cold start]
tags: [core]
core: true
context_cost: medium
---
# Session Resume Skill

## Goal
Allow ANY agent at ANY time to load the complete project state and continue as if they were there from the beginning. Zero knowledge loss between sessions. Always run integrity-check before continuing to verify current state.

> **Boot order:** this skill is the *memory-load* step that `preflight.skill` delegates to on a
> cold start / resume — it does not call `preflight` back. Canonical order: preflight → integrity-check
> → **session-resume (here)** → return to preflight for the capability summary. (See `preflight.skill`.)

## Steps

1. **Load PROJECT_STATE.md** (primary state file)
   - Read: `agents/memory/PROJECT_STATE.md`
   - Determine: current lifecycle phase — any of S00–S13 (Day-0 S00, core build loop S01–S10,
     Day-2 S11–S13). S00 and S11–S13 are real phases; resume into them, do not skip them.
   - Note: last checkpoint, last completed milestone, current blockers

2. **Load CONTINUITY.md** (past failures — CRITICAL, read before doing anything)
   - Read: `agents/memory/CONTINUITY.md`
   - Identify: any past failed approaches relevant to current work
   - Note: libraries that caused conflicts, patterns that didn't work, decisions reversed

3. **Load AUDIT_LOG.md** (recent history)
   - Read last 50 entries from: `agents/memory/AUDIT_LOG.md`
   - Understand: recent decisions, what was completed, what was blocked

4. **Load latest SESSION_SNAPSHOT** (working context)
   - Find the most recent file in: `agents/memory/episodic/SESSION_SNAPSHOT/`
   - Read the snapshot for the current SDLC phase
   - Restore: task context, open questions, implementation decisions

5. **Load semantic knowledge** (crystallized facts)
   - Read: `agents/memory/semantic/PROJECT_KNOWLEDGE_TEMPLATE.md`
   - Note: verified library APIs, confirmed architecture decisions, known constraints

6. **Read current project/TASKS.md**
   - Identify: all TODO tasks, IN_PROGRESS tasks, BLOCKED tasks
   - Note: any tasks that are blocked and what's blocking them

7. **Run integrity-check.skill** (before starting any new work)
   - Verify current codebase matches the state recorded in memory
   - Catch: any changes made outside of agent sessions, merge conflicts, etc.
   - If integrity fails: investigate before proceeding

8. **Produce Resume Report** (present to human before continuing)
   ```markdown
   ## Project Resume Report

   ### Project State
   - Current lifecycle phase: [SXX — Phase Name] (one of S00–S13)
   - Last checkpoint: [date] at [phase]
   - Overall progress: [X/14 lifecycle phases complete (S00–S13); core build loop = S01–S10]

   ### What Was Completed (last session)
   - [list of completed tasks/phases]

   ### What Was In Progress
   - [task name] — [where it was left, what remains]

   ### Blocked Items
   - [task] blocked by: [reason / pending human decision]

   ### Open Human Decisions Pending
   - [question 1 still waiting for answer]

   ### Known Issues / Constraints (from CONTINUITY.md)
   - [any relevant past failures to avoid repeating]

   ### Integrity Check Result
   - [PASS/FAIL — details if fail]

   ### Recommended Next Action
   [What I will do next, starting from: task X in project/TASKS.md]

   Ready to continue? Please confirm or direct me to a different task.
   ```

9. **Wait for human confirmation** before starting work
   - Human may redirect to different priority
   - Human may resolve pending decisions listed in report

10. **Continue from next pending task**
    - Pick up from the first TODO or IN_PROGRESS task in project/TASKS.md
    - Apply RARV cycle (guides/processes/RARV_CYCLE.md)

## Memory Loading Order (critical — load in this sequence)

```
1. RESUME_POINTER.md   → the single "where am I" lifeline: current task + NEXT ACTION (read FIRST)
2. PROJECT_STATE.md    → SDLC phase, last checkpoint
3. CONTINUITY.md       → past failures (MOST IMPORTANT — read before anything)
4. AUDIT_LOG.md        → last 50 entries (recent decisions)
5. SESSION_SNAPSHOT/   → latest milestone snapshot
6. semantic/           → crystallized project knowledge
7. project/TASKS.md            → current task status
8. integrity-check     → verify state is consistent
```
`RESUME_POINTER.md` is written first on every save by `state-preserve.skill`, so it
is the minimal lifeline and is read first here. Continue from its `NEXT ACTION`.

## Constraints
- NEVER start new work without first completing all loading steps above (incl. RESUME_POINTER)
- NEVER skip the integrity check — it catches silent state corruption
- If CONTINUITY.md mentions a failed approach: do NOT repeat it
- If human decisions are pending in AUDIT_LOG: surface them before starting new work

## Output Format
Resume Report (presented to human) + confirmation of which task will be worked on next.

## Security & Guardrails

### 1. Skill Security (Session Resume)
- **State Integrity Verification**: Before loading the state, the agent must verify the Sha-256 checksums or cryptographic signatures of all core memory files (`PROJECT_STATE.md`, `AUDIT_LOG.md`) to detect if they were tampered with while the system was offline.
- **Credential Ephemerality**: Session resumption must NEVER load raw API keys, database credentials, or access tokens from text files. The skill must re-authenticate with the Secret Manager (e.g., HashiCorp Vault, AWS Secrets Manager) using its IAM role upon waking.

### 2. System Integration Security
- **Drift Detection**: The `integrity-check.skill` executed during resume must diff the current `HEAD` against the last known `git tag`. Unaudited code shifts (e.g., a backdoor merged by a compromised developer account while the agent slept) must force an immediate lockdown.
- **Suspended Thread Monitoring**: Ensure that any asynchronous background processes (e.g., database index builds) initiated prior to the session suspension have either safely terminated or are actively monitored upon resumption to prevent race conditions.

### 3. LLM & Agent Guardrails
- **Amnesia Exploitation Defense**: A malicious prompt sequence could attempt to force a "resume" from an artificially constructed, backdoored `SESSION_SNAPSHOT`. The agent must reject loading any snapshot that is not chronologically continuous and cryptographically signed.
- **Context Window Verification**: When loading the 7 memory files into the LLM context, the agent must rigorously verify that the combined token count does not exceed the context window, causing critical operational constraints (e.g., security boundaries loaded near the end) to be silently truncated.