@zalom/plastic 1.0.0-alpha.9 → 1.0.0-beta.2

package/skills/auto/evals/evals.json

@@ -0,0 +1,207 @@
+{
+  "skill_name": "plastic-auto",
+  "notes": "Intent 27. Scopes: description triggering (1-8) and behavior/output quality (9). Assertions written after observing Step-3 runs (one clean subagent router per case). Intent 63 added cases 10-11 (auto-mode enforcer-led team spin-up and solo fallback).",
+  "results": {
+    "triggering": {
+      "cases": 8,
+      "passed": 8,
+      "pass_at_1": 1.0,
+      "run": "2026-06-10, one subagent per case"
+    },
+    "behavior": {
+      "cases": 1,
+      "passed": 1,
+      "evidence": "dogfood: intent 27 itself delivered via auto produced spec->plan->checklist before any code edit; code-gate unit test proves pre-How project-code edits are blocked"
+    }
+  },
+  "evals": [
+    {
+      "id": 1,
+      "scope": "triggering",
+      "set": "train",
+      "prompt": "auto",
+      "expected_output": "Activates plastic-auto (the bare 'auto' keyword is the documented trigger).",
+      "files": [],
+      "assertions": [
+        {
+          "type": "code",
+          "check": "router CHOICE == plastic-auto",
+          "observed": "plastic-auto",
+          "result": "pass"
+        }
+      ]
+    },
+    {
+      "id": 2,
+      "scope": "triggering",
+      "set": "train",
+      "prompt": "take it from here and deliver intent 27 end to end",
+      "expected_output": "Activates plastic-auto (autonomous delivery of an active intent).",
+      "files": [],
+      "assertions": [
+        {
+          "type": "code",
+          "check": "router CHOICE == plastic-auto",
+          "observed": "plastic-auto",
+          "result": "pass"
+        }
+      ]
+    },
+    {
+      "id": 3,
+      "scope": "triggering",
+      "set": "validation",
+      "prompt": "go fully autonomous on the active intent, don't ask me questions",
+      "expected_output": "Activates plastic-auto.",
+      "files": [],
+      "assertions": [
+        {
+          "type": "code",
+          "check": "router CHOICE == plastic-auto",
+          "observed": "plastic-auto",
+          "result": "pass"
+        }
+      ]
+    },
+    {
+      "id": 4,
+      "scope": "triggering",
+      "set": "train",
+      "prompt": "deliver this intent for me",
+      "expected_output": "Activates plastic-auto.",
+      "files": [],
+      "assertions": [
+        {
+          "type": "code",
+          "check": "router CHOICE == plastic-auto",
+          "observed": "plastic-auto",
+          "result": "pass"
+        }
+      ]
+    },
+    {
+      "id": 5,
+      "scope": "triggering",
+      "set": "train",
+      "prompt": "set up a hook to automatically format the file on every save",
+      "expected_output": "Does NOT activate plastic-auto. Near-miss: shares 'auto*' but is a settings/hooks task (update-config).",
+      "files": [],
+      "assertions": [
+        {
+          "type": "code",
+          "check": "router CHOICE != plastic-auto",
+          "observed": "update-config",
+          "result": "pass"
+        }
+      ]
+    },
+    {
+      "id": 6,
+      "scope": "triggering",
+      "set": "validation",
+      "prompt": "deliver the built package to the dist directory",
+      "expected_output": "Does NOT activate plastic-auto. Near-miss: shares 'deliver' but is a build/file task.",
+      "files": [],
+      "assertions": [
+        {
+          "type": "code",
+          "check": "router CHOICE != plastic-auto",
+          "observed": "none",
+          "result": "pass"
+        }
+      ]
+    },
+    {
+      "id": 7,
+      "scope": "triggering",
+      "set": "train",
+      "prompt": "create a new intent for the dashboard idea",
+      "expected_output": "Does NOT activate plastic-auto; activates plastic-creating-intent.",
+      "files": [],
+      "assertions": [
+        {
+          "type": "code",
+          "check": "router CHOICE != plastic-auto",
+          "observed": "plastic-creating-intent",
+          "result": "pass"
+        }
+      ]
+    },
+    {
+      "id": 8,
+      "scope": "triggering",
+      "set": "validation",
+      "prompt": "what's the status of my active intents?",
+      "expected_output": "Does NOT activate plastic-auto; this is a read/continuing/managing-index query.",
+      "files": [],
+      "assertions": [
+        {
+          "type": "code",
+          "check": "router CHOICE != plastic-auto",
+          "observed": "plastic-managing-index",
+          "result": "pass"
+        }
+      ]
+    },
+    {
+      "id": 9,
+      "scope": "behavior",
+      "set": "train",
+      "prompt": "Active intent X exists with only a '## Intent' section. Deliver it in auto mode.",
+      "expected_output": "Arms the lifecycle gate first, then produces spec.md (Why), then plan.md + actions/ + checklist.md (How), and edits NO project code before plan.md + checklist.md exist. Disarms on completion.",
+      "files": [],
+      "assertions": [
+        {
+          "type": "human",
+          "check": "spec.md written before plan.md before any project-code edit",
+          "observed": "dogfood run of intent 27 followed this order",
+          "result": "pass"
+        },
+        {
+          "type": "code",
+          "check": "code-gate blocks project-code Edit/Write while pre-How (test/code_gate_test.rb)",
+          "observed": "test green",
+          "result": "pass"
+        }
+      ]
+    },
+    {
+      "id": 10,
+      "scope": "behavior",
+      "set": "train",
+      "prompt": "Active intent X exists. Deliver it in auto mode on a harness that supports subagents.",
+      "expected_output": "Spins up one enforcer-led team per intent (brainstorming, spec-specialist, planner, executor, plastic-enforcer). The enforcer IS the orchestrator. Dispatches one specialist per stage sequentially on one branch, gating each deliverable (Context+Decisions, then spec.md, then plan.md+actions+checklist, then code) against the stage exit criteria before handoff, and dispatches an independent reviewer subagent at the final gate only.",
+      "files": [],
+      "assertions": [
+        {
+          "type": "human",
+          "check": "five-role roster spun up; specialists dispatched stage-sequentially with per-stage gating; independent reviewer only at final gate",
+          "observed": "dogfood: intents 60-62 delivered by exactly this enforcer-led team on a shared branch",
+          "result": "pass"
+        },
+        {
+          "type": "code",
+          "check": "agents/plastic-*.md role files ship and install into the harness agent dir, manifest-tracked (test/install_packaging_test.rb)",
+          "observed": "test green",
+          "result": "pass"
+        }
+      ]
+    },
+    {
+      "id": 11,
+      "scope": "behavior",
+      "set": "validation",
+      "prompt": "Active intent X exists. Deliver it in auto mode on a harness with no subagent dispatch.",
+      "expected_output": "Falls back to a single agent walking the full What, Why, How, Exec cycle itself, preserving current behavior. The enforcer gate discipline still applies (arm the gate first, no project-code edits before plan.md + checklist.md exist).",
+      "files": [],
+      "assertions": [
+        {
+          "type": "human",
+          "check": "solo agent walks the full cycle when subagent dispatch is unavailable; gate discipline preserved",
+          "observed": "SKILL.md Team Spin-Up documents the solo fallback explicitly",
+          "result": "pass"
+        }
+      ]
+    }
+  ]
+}

package/skills/auto/references/agent-architecture.md

@@ -0,0 +1,135 @@
+# Agent Architecture
+
+## Main Orchestrator
+
+The Main Orchestrator manages the global store (Main Knowledge Base). It:
+- Recognizes, creates, updates, and groups intents
+- Spawns Project Orchestrators for registered projects
+- Receives contributions back from Project Orchestrators
+- Is the only agent that runs in a loop (continuous Build, Observe, Repeat)
+
+## Project Orchestrators
+
+Project Orchestrators manage project stores (Project Knowledge Bases). They:
+- Care about intents and execution within their project
+- Spin up an enforcer-led team to deliver an intent
+- Contribute back to the Main Orchestrator when new intents are born
+  that could enrich the Main Knowledge Base
+
+## The Auto-Mode Team
+
+Auto mode spins up exactly ONE enforcer-led team per intent. The plastic-enforcer
+IS the auto orchestrator itself, not a separately dispatched agent. Making the
+orchestrator the enforcer avoids the who-gates-the-gater regress (the gate-keeper
+can never be ungated).
+
+The team has five roles, one per place in the What, Why, How, Exec cycle:
+
+- **plastic-brainstorming** (Why exploration): enriches `## Context` and records
+  `### Decisions` with rationale.
+- **plastic-spec-specialist** (Why-to-How boundary): consolidates the Why into
+  `spec.md` (Problem, Goals, Non-Goals, Approach, Decisions, Acceptance Criteria).
+- **plastic-planner** (How): produces `plan.md`, `actions/ACTION_N.md`, and
+  `checklist.md`.
+- **plastic-executor** (Exec): writes the code, checks off `checklist.md`, appends
+  `## Insights`, and drives the suite green.
+- **plastic-enforcer** (spans the whole cycle): orchestrates and gates.
+
+### Handoff Contracts
+
+Each specialist receives the prior stage's deliverable and produces the next stage's
+input. The enforcer dispatches one specialist per stage with a constructed context
+bundle, gates that deliverable against the stage's exit criteria, and only then hands
+off to the next stage. Dispatch is sequential on a single branch, because the stage
+deliverables share files (a parked spec, plan, and checklist all live in the same
+intent directory).
+
+The chain: intent `## Intent` / `## Context`, then enriched `## Context` plus
+`### Decisions`, then `spec.md`, then `plan.md` plus `actions/` plus `checklist.md`,
+then the code changes plus a checked-off checklist plus `## Insights`.
+
+### Spawn Preamble (L2 live-state injection)
+
+Every dispatched specialist is booted with a spawn preamble: the enforcer runs
+`scripts/spawn-preamble <intent_dir> --role <role>` and prepends its output to the
+specialist's prompt. The preamble is a pure function of the intent directory on disk
+(no network, no clock, no randomness), so it is deterministic and rebuildable. It
+carries the active intent id and intent line, the current lifecycle stage (the last
+savepoint line, else stage derived from which lifecycle files exist), the cycle
+role, and the honoring instruction that the agent must emit valid lifecycle artifacts
+and not hallucinate intents or stages. This is the standard L2 live-state mechanism
+for harnesses whose spawned sub-agents do not inherit the top-level session event. See
+`docs/reference/harness-adapters.md` for how it slots into the per-harness contract.
+
+### Gate Ownership
+
+The enforcer arms and verifies the lifecycle gate, then gates every stage transition.
+It never delegates gate ownership. At the final gate only, it dispatches an
+INDEPENDENT reviewer subagent to review the delivered work. That reviewer is not a
+permanent sixth role, it exists only for the final review.
+
+### Headless Manual Gate
+
+When running headless or in the background, the enforcer enforces gates manually and
+does not rely on hooks, because `CLAUDE_SESSION_ID` may be unset in those runs (the
+gate-check and savepoint hooks no-op without it). The enforcer arms via the bridge's
+derived-key fallback and verifies state itself.
+
+### Delegation
+
+The roles are thin handoff contracts, not a spawning engine. Dispatch and review run
+by default through Plastic's own engine, `plastic-executing-plan` (implementer plus
+two-stage review, no external plugin). When `superpowers:subagent-driven-development`
+and `superpowers:dispatching-parallel-agents` are available, or the user asks for them,
+they delegate to those as an enhancement. The team model defines who hands what to whom
+and where the gates sit; the dispatch engine, native or superpowers, does the actual
+spawning.
+
+### Fallback by Case
+
+The default is always Plastic's native engine, so a user without superpowers still gets
+the full behavior. If the harness supports subagents but superpowers is absent, auto
+mode dispatches through `plastic-executing-plan`. If the harness has no subagent dispatch
+at all, auto mode falls back to a single agent walking the full What, Why, How, Exec
+cycle itself. The enforcer's gate discipline still applies in every case.
+
+### Dogfood Proof
+
+Intents 60, 61, and 62 were delivered by exactly this enforcer-led team on a shared
+branch, which is the dogfooded proof that the model works end to end.
+
+## Two Modes
+
+- **Human-driven:** Human chats with the Main Orchestrator, creates intents,
+  brainstorms, then the Main Orchestrator dispatches Project Orchestrators and teams
+  for execution.
+- **Autonomous:** Human gives the Main Orchestrator a starting intent with defined
+  outcomes. The enforcer-led team runs the full cycle (the specialists do the
+  lifecycle, the enforcer reviews Insights and gates), then the orchestrator spawns
+  next intents and dispatches again.
+
+## Autonomous Delivery
+
+Human owns What and Why for human-initiated intents. The team assists (research,
+exploration) but the human drives until handoff. When Why is complete, or the human
+triggers `plastic-auto`, the enforcer-led team takes over How and Exec autonomously.
+
+- **Safe-by-default:** the executor always prefers non-destructive routes (rename vs
+  delete, additive migrations, backups before changes). Destructive actions on
+  existing projects require human approval unless `--skip-permissions` is set.
+- **Notification only on:** finish or hard stop (blocked on destructive action,
+  unresolvable error). No progress reports, `## Insights` tracks everything.
+- **Greenfield autonomy:** during initial project creation, all decisions are
+  non-destructive (nothing to destroy), so the team has full autonomy for greenfield
+  choices.
+- **Autonomous decisions** are logged in `## Insights` with the `(autonomous)` marker.
+
+## Coordinator Loop
+
+When "work on Project X":
+1. Read `projects.yml`, find the project path
+2. Load global config (defaults)
+3. Load project config (overrides)
+4. Load global INDEX.md, find hub intents tagged `project-<name>`
+5. Load project INDEX.md, find tactical intents
+6. The coordinator has the full picture, spins up an enforcer-led team per intent

package/skills/brainstorming/SKILL.md

@@ -1,5 +1,5 @@
 ---
-name: plastic:brainstorming
+name: plastic-brainstorming
 description: "Explore intent requirements and design before implementation. Produces spec.md in the active intent directory."
 ---
 
@@ -20,7 +20,7 @@ Do NOT invoke any implementation skill, write any code, scaffold any project, or
 Before proceeding, resolve the active intent:
 
 1. **Detect store:** Read `~/.plastic/projects.yml`, match CWD against registered project paths. If match → project store at `~/.plastic/projects/{slug}/store/`. If no match → global store at `~/.plastic/store/`.
-2. **Find active intent:** Read `INDEX.md` from the detected store. Look under `## Active`. If exactly one → use it. If multiple → ask which. If none → refuse: "No active intent. Create one first with /plastic:creating-intent"
+2. **Find active intent:** Read `INDEX.md` from the detected store. Look under `## Active`. If exactly one → use it. If multiple → ask which. If none → refuse: "No active intent. Create one first with /plastic-creating-intent"
 3. **Resolve intent directory:** `{store}/store/{id}--{slug}/`
 
 All artifacts go to the intent directory. Never write to external paths.
@@ -40,7 +40,7 @@ You MUST create a task for each of these items and complete them in order:
 5. **Write spec** — save to `{intent_dir}/spec.md` and commit to store repo
 6. **Spec self-review** — placeholder scan, consistency, scope, ambiguity
 7. **User reviews written spec** — ask user to review before proceeding
-8. **Transition to planning** — invoke `plastic:writing-plans`
+8. **Transition to planning** — invoke `plastic-writing-plans`
 
 ## Process Flow
 
@@ -54,7 +54,7 @@ digraph brainstorming {
     "Write spec" [shape=box];
     "Spec self-review\n(fix inline)" [shape=box];
     "User reviews spec?" [shape=diamond];
-    "Invoke plastic:writing-plans" [shape=doublecircle];
+    "Invoke plastic-writing-plans" [shape=doublecircle];
 
     "Explore project context" -> "Ask clarifying questions";
     "Ask clarifying questions" -> "Propose 2-3 approaches";
@@ -65,11 +65,11 @@ digraph brainstorming {
     "Write spec" -> "Spec self-review\n(fix inline)";
     "Spec self-review\n(fix inline)" -> "User reviews spec?";
     "User reviews spec?" -> "Write spec" [label="changes requested"];
-    "User reviews spec?" -> "Invoke plastic:writing-plans" [label="approved"];
+    "User reviews spec?" -> "Invoke plastic-writing-plans" [label="approved"];
 }
 ```
 
-**The terminal state is invoking `plastic:writing-plans`.** Do NOT invoke any other implementation skill. The ONLY skill you invoke after brainstorming is `plastic:writing-plans`.
+**The terminal state is invoking `plastic-writing-plans`.** Do NOT invoke any other implementation skill. The ONLY skill you invoke after brainstorming is `plastic-writing-plans`.
 
 ## The Process
 
@@ -107,7 +107,7 @@ digraph brainstorming {
 
 ## After the Design
 **Documentation:**
-- Write the validated design (spec) to `{intent_dir}/spec.md`
+- Write the validated design (spec) to `{intent_dir}/spec.md` using the `${CLAUDE_PLUGIN_ROOT}/templates/spec.md` form
 - Use elements-of-style:writing-clearly-and-concisely skill if available
 - Commit to the store repo:
   ```
@@ -130,8 +130,8 @@ After the spec review loop passes, ask the user to review the written spec befor
 Wait for the user's response. If they request changes, make them and re-run the spec review loop. Only proceed once the user approves.
 
 **Implementation:**
-- Invoke `plastic:writing-plans` to create the implementation plan
-- Do NOT invoke any other skill. `plastic:writing-plans` is the next step.
+- Invoke `plastic-writing-plans` to create the implementation plan
+- Do NOT invoke any other skill. `plastic-writing-plans` is the next step.
 
 ## Key Principles
 

package/skills/brainstorming-grill-me/SKILL.md

@@ -1,9 +1,9 @@
 ---
-name: plastic:brainstorming-grill-me
+name: plastic-brainstorming-grill-me
 description: >-
   Deep brainstorming that interviews the user relentlessly about a plan or design until reaching shared understanding.
   Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".
-  Complements superpowers:brainstorming — use brainstorming for quick ideation, grill-me for thorough interrogation.
+  Pair with plastic-brainstorming for quick ideation and use grill-me for thorough interrogation. If superpowers:brainstorming is installed it complements this skill, but it is not required.
 ---
 
 # Grill Me — Deep Brainstorming
@@ -83,18 +83,18 @@ If ALL items pass, offer autonomous delivery:
 >
 > Want to grill more, or should I go autonomous?"
 
-- If human says go → invoke `plastic:auto`
+- If human says go → invoke `plastic-auto`
 - If human says grill more → continue grilling (reset to step 2)
 - If human says neither (wants to drive manually) → proceed as before (offer planning)
 
 This offer replaces the final question in Close Out ("Ready to plan implementation, or do you want another pass?"). The new options are:
-1. Go autonomous (`plastic:auto`)
+1. Go autonomous (`plastic-auto`)
 2. Grill more (continue interrogation)
 3. Plan manually (invoke `superpowers:writing-plans` or proceed with human-driven planning)
 
 ## Relationship to superpowers:brainstorming
 
-| | superpowers:brainstorming | plastic:brainstorming-grill-me |
+| | superpowers:brainstorming | plastic-brainstorming-grill-me |
 |---|---|---|
 | Speed | Quick (5-10 min) | Thorough (20-45 min) |
 | Depth | Surface-level exploration | Exhaustive decision tree |
@@ -102,4 +102,4 @@ This offer replaces the final question in Close Out ("Ready to plan implementati
 | Output | Initial spec | Battle-tested spec with all branches resolved |
 | Style | Collaborative, exploratory | Interrogative, relentless |
 
-Use `superpowers:brainstorming` to generate ideas. Use `plastic:brainstorming-grill-me` to pressure-test them.
+Use `superpowers:brainstorming` to generate ideas. Use `plastic-brainstorming-grill-me` to pressure-test them.

package/skills/continuing/SKILL.md

@@ -1,104 +1,114 @@
 ---
-name: plastic:continuing
-description: Use when the user says "continue" after a /clear, or when resuming work in a new session. Reads intent state from global store (~/.plastic/) or local store, offers active intents first, then future intents, and surfaces stale intents for triage.
+name: plastic-continuing
+description: Use when the user says "continue", "resume", or "pick up where we left off", or when starting a new session. Continues work with the latest project context: lands on the right dashboard, then presents choices. Boot (health check, core context, version, statusline) is owned by the SessionStart hook, not this skill. Does not drive work autonomously (that is plastic-auto).
 ---
 
 # Continuing
 
+`plastic-continuing` continues work. It presents the latest state via the dashboard and offers
+choices, then stops. It does NOT execute work autonomously (that is `plastic-auto`) and does
+NOT render the dashboard itself (it only invokes it).
+
+**Boot is not this skill's job.** The `hook-session-start` hook already runs by construction on
+every session start: it runs the core health check (`doctor --core`), primes `PLASTIC.md` +
+store/project state, and prints the `Plastic Core loaded — v{version}` banner. The
+`plastic-statusline` hook sets the statusline. So by the time this skill runs, core is loaded
+and healthy (or the banner already warned otherwise). This skill picks up from there and
+continues work. This is the seam future continue-flags build on (see [[39]]).
+
 ## When to Use
 - UserPromptSubmit hook detects "continue" (automatic)
 - User says "continue", "resume", or "pick up where we left off"
-- Starting a new session with existing active intents
+- Starting a new session and you want to resume work with the latest context
 
 ## Determine Store
 
-1. Check `~/.plastic/INDEX.md` → global mode
-2. 
-3. If neither exists → announce "No Plastic store found. Run /plastic:install."
-
-## Workflow
-
-### 1. Read INDEX.md
-Read the INDEX.md from the active store. Extract intents under `## Active` and `## Future`.
-
-### 2. Detect Current Project (global mode only)
-Read `~/.plastic/projects.yml`, match CWD against registered project paths. If in a project:
-- Load the governing intent (from `parent` in projects.yml)
-- Load tactical intents from `~/.plastic/projects/{slug}/store/`
-
-### 3. If Active Intents Exist → Resume
-
-For each active intent in the store:
-
-**a. Read `{ID}--{slug}.md`:**
-- What we're doing (`## Intent`)
-- Why (`## Context`)
-- What insights have emerged (`## Insights`)
-
-**b. Read savepoint.md** (if exists):
-- What was in progress, what's next, blockers
-
-**c. Read checklist.md** (if exists):
-- What's completed, what's next
-
-**d. Announce:**
-```
-Resuming intent [ID] — [name]
-Store: [global | project:<slug> | local]
-Status: active
-Last session: [date from savepoint]
-In progress: [from savepoint]
-Next step: [from checklist or savepoint]
-Blockers: [from savepoint, or "none"]
-```
-
-**e. Resume** — proceed with the next step.
-
-### 3b. Detect Autonomous Resume
-
-When resuming an active intent, check `## Insights` for entries containing `(autonomous)`.
-
-If found — this intent was being delivered autonomously:
-
-**Announce:**
-```
-Resuming autonomous delivery of intent [ID] — [name]
-Store: [global | project:<slug> | local]
-Last autonomous action: [last (autonomous) insight entry]
-Next step: [from checklist or savepoint]
-```
-
-**Then:** Continue autonomous execution by invoking `plastic:auto`. The auto skill will pick up from the current lifecycle stage (it reads filesystem state to determine where to resume).
-
-If NOT found — resume normally as described in step 3.
-
-### 4. If No Active Intents → Offer Future Intents
-
-Present future intents as options. When user picks one, move to Active in INDEX.md. Auto-commit.
-
-### 5. Surface Stale Future Intents
-
-If any future intent has `created` date older than the configured `stale_threshold_days` (default 3):
+1. **Global store** — `~/.plastic/INDEX.md` exists → global mode.
+2. **Local store** — a project store under `~/.plastic/projects/{slug}/` whose registered
+   path (in `~/.plastic/projects.yml`) matches the current working directory → project mode.
+   The SessionStart hook already detects this; here you only need the slug to scope the
+   dashboard.
+3. If neither exists → announce "No Plastic store found. Run /plastic-install."
+
+## Continue (present the dashboard)
+
+Land on the Markdown board via the `plastic-dashboard` skill. Rendering belongs there, not
+here — run the data payload and fill + present the matching template:
+- Project loaded → `ruby ~/.plastic/scripts/dashboard.rb project <slug> --data`
+- Otherwise → `ruby ~/.plastic/scripts/dashboard.rb continue --data`
+
+Fill the matching template from this skill's `templates/` and **present the filled Markdown
+in your reply** (every time). See `plastic-dashboard` for the fill rules and entry flow.
+
+The board load runs the scoped store check on every load (`doctor --store <scope>`): the
+global board runs `--store global` and a project board runs `--store <slug>`. The result
+arrives in the payload as `store_health`; surface it as a one-line store-health note. It is
+non-fatal (a warn or fail is shown as data, it does not block continuing).
+
+### Then stop
+Present "here is the state, what next?" and wait. Offer active intents first, then future
+intents. Do not start executing work. The branches below are the only follow-ups:
+- User/agent names a specific intent to continue → **Conditional ledger-resume** (below).
+- User says "auto" / an agent is instructed to deliver → hand to `plastic-auto`.
+
+## Conditional Ledger-Resume
+
+Fires ONLY when the user explicitly asks to continue a SPECIFIC intent, or an agent is
+instructed to continue one. It is not part of every boot. For that intent's directory:
+
+1. **Read `savepoint.md`.** It is a deterministic, append-only stage ledger (one line per
+   milestone, newest at the bottom): `{utc-iso8601}  {Stage}  {milestone}`. The **last line =
+   current stage**.
+2. **Verify the stage file.** Confirm the file the ledger names exists and is non-empty
+   (ledger `How  plan.md created` → `plan.md` must be present and non-empty).
+3. **Drift handling.** If the ledger's last line disagrees with files-on-disk, rebuild the
+   ledger from filesystem state and note the correction:
+   ```bash
+   ruby -r ~/.plastic/scripts/lib/bridge -e 'Bridge.rebuild_savepoint("<intent_dir>")'
+   ```
+4. **Derive the next step:**
+   - First unchecked item in `checklist.md` if it exists, else
+   - "advance to the next lifecycle stage" (e.g. ledger shows Why/spec.md → next is How).
+   - The newest `## Insights` entry supplies human-readable context (Insights are
+     append-only, newest at the bottom).
+5. **Announce and stop:**
+   ```
+   Resuming intent [ID] — [name]
+   Store: [global | project:<slug> | local]
+   Stage: [from ledger last line]
+   Next step: [first unchecked checklist item | advance to <stage>]
+   Context: [newest ## Insights entry]
+   Drift: [none | ledger rebuilt from filesystem]
+   ```
+   Then proceed with the next step. Autonomy is `plastic-auto`'s job — if the intent's
+   `## Insights` contains `(autonomous)` entries, it was being delivered autonomously; hand
+   to `plastic-auto` to continue from the current stage.
+
+## Priority Order
+
+1. **Active intents first** — surface work in progress.
+2. **Project context** — if in a registered project, show governing + tactical intents.
+3. **Stale future intents** — surface for triage (see below).
+4. **Fresh future intents** — offer as next work.
+
+## Stale Future Intents
+
+If a future intent's `created` date is older than the configured `stale_threshold_days`
+(default 3), surface it for triage without taking action:
 
 ```
 Stale future intents (no action taken):
 
 - [ID — name] (X days old)
-  Options:
   a) Activate — start working on it now
   b) Abandon — mark as abandoned
-  c) Defer to agent:
-     - implement: agent builds it
-     - research: agent investigates feasibility
-     - ideate: agent explores the problem space
-  d) Auto — go fully autonomous (invokes plastic:auto — agent delivers the intent end-to-end)
+  c) Defer to agent: implement | research | ideate
+  d) Auto — go fully autonomous (invokes plastic-auto)
 ```
 
-Auto-commit all triage changes.
+When the user activates a future intent, move it to `## Active` in INDEX.md and auto-commit.
 
-### 6. Priority Order
+## References
 
-1. **Active intents first** — resume work in progress
-2. **Project context** — if in a registered project, show governing intent + tactical intents
-3. **Stale future intents** — surface for triage
-4. **Fresh future intents** — offer as next work
+- Read `references/context-management.md` for the full save/continue protocol and for
+  debugging the resume flow.