@zalom/plastic 1.1.0 → 1.1.1

package/scripts/roadmap-savepoint

@@ -0,0 +1,64 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# roadmap-savepoint - deterministic CLI over RoadmapSavepoint (intent 134).
+#
+# The plastic-roadmap skill verbs and the coordinator flows call this instead of hand-writing
+# ledger lines. append is idempotent on the (event, detail) pair; rebuild is the one operation
+# allowed to overwrite the ledger, reconstructing it from the roadmap's own `## Log`.
+#
+# Usage:
+#   roadmap-savepoint append --roadmap <path> --event <event> --detail "<text>"
+#   roadmap-savepoint rebuild --roadmap <path>
+#
+# Exits non-zero with a usage line on stderr for an unknown verb or a missing required flag.
+
+require_relative "lib/roadmap_savepoint"
+
+def opt(args, name)
+  (i = args.index(name)) && args[i + 1]
+end
+
+def usage
+  warn "Usage: roadmap-savepoint append --roadmap <path> --event <event> --detail \"<text>\""
+  warn "       roadmap-savepoint rebuild --roadmap <path>"
+end
+
+verb = ARGV.shift
+
+case verb
+when "append"
+  roadmap = opt(ARGV, "--roadmap")
+  event = opt(ARGV, "--event")
+  detail = opt(ARGV, "--detail")
+  if roadmap.nil? || event.nil? || detail.nil?
+    warn "append: pass --roadmap <path> --event <event> --detail \"<text>\""
+    usage
+    exit 2
+  end
+  begin
+    wrote = RoadmapSavepoint.append(roadmap, event, detail)
+    puts wrote ? "appended #{event}  #{detail}" : "no-op (already recorded): #{event}  #{detail}"
+    exit 0
+  rescue ArgumentError => e
+    warn "append: #{e.message}"
+    exit 2
+  end
+
+when "rebuild"
+  roadmap = opt(ARGV, "--roadmap")
+  if roadmap.nil?
+    warn "rebuild: pass --roadmap <path>"
+    usage
+    exit 2
+  end
+  count = RoadmapSavepoint.rebuild(roadmap)
+  puts "rebuilt #{count} line#{count == 1 ? '' : 's'}"
+  exit 0
+
+else
+  warn "roadmap-savepoint: unknown verb #{verb.inspect}. Use append|rebuild."
+  usage
+  exit 2
+end

package/skills/auto/SKILL.md

@@ -15,7 +15,9 @@ Announce: "Taking over intent [ID] - [name] for autonomous delivery."
 orchestrating main session on the best available thinking model (Fable, Opus, or whatever
 supersedes them) for the sharpest gating and synthesis. This is advice only: it changes no
 behavior and blocks nothing if ignored. It concerns the human's MAIN session; dispatched
-subagents keep their pinned tier and never resolve to Fable.
+subagents keep their pinned tier and never resolve to Fable, unless an explicit
+`agents.models.<name>` config override names Fable for that role, in which case the override
+is honored as written.
 
 ## Precondition
 
@@ -24,8 +26,22 @@ An active intent MUST exist in INDEX.md. If none exists, refuse: "No active inte
 If multiple active intents exist, ask the user which one to deliver (this is the only question auto asks).
 
 **Picking work when no intent is specified.** If the user says "auto" without naming an
-intent and none is active, consult the dashboard's machine-readable queue to choose the
-next dispatchable intent:
+intent and none is active, consult the roadmap first (the primary planning surface), then
+fall back to the dashboard queue. Read the tier's mid-flight roadmap:
+
+```bash
+ruby ~/.plastic/scripts/roadmap-next --roadmaps-dir <tier>/roadmaps
+```
+
+Branch on `state`:
+- `dispatchable`: work its `dispatchable_queue` in `rank` order (the head is the next batch
+  entry). These are the current batch's `queued` intents, parallel-safe within the wave.
+- `in_flight`: the frontier batch is still delivering. Report it and wait. Do NOT dispatch a
+  later batch and do NOT fall through to the dashboard, the roadmap is live.
+- `none` or `exhausted`: no roadmap, or nothing left to dispatch. Fall back to the dashboard
+  queue below. (The global store has no roadmap, so it always reports `none` and falls back.)
+
+Dashboard fallback:
 
 ```bash
 ruby ~/.plastic/scripts/dashboard.rb all --json
@@ -108,7 +124,9 @@ Dispatch rule: sequential, one specialist per stage on one branch (the deliverab
 
 Spawn preamble (live-state injection): before dispatching any specialist, run `scripts/spawn-preamble <intent_dir> --role <role>` and PREPEND its output to that specialist's prompt. The preamble is a deterministic, filesystem-only snapshot of the active intent (id, intent line, current stage, and the provisioned code worktree path when one exists on disk) plus the honoring instruction, so every spawned agent boots with accurate live state instead of guessing. This is the authoritative L2 mechanism for harnesses whose sub-agents do not inherit a top-level session event (see `docs/reference/harness-adapters.md`).
 
-Dispatch-time model contract (belt-and-braces): alongside the preamble, resolve each specialist's model through the config chain (`read-config agents.models.<basename> --project <repo>`: project override, then global, then the shipped tier default) and pass it explicitly at dispatch. Never rely on the dispatched role's frontmatter alone; a resolved subagent model is never Fable.
+Dispatch-time model contract (belt-and-braces): alongside the preamble, resolve each specialist's model through the config chain (`read-config agents.models.<basename> --project <repo>`: project override, then global, then the shipped tier default) and pass it explicitly at dispatch. Never rely on the dispatched role's frontmatter alone; a resolved subagent model is never Fable,
+unless an explicit `agents.models.<name>` config override names Fable for that role, in which
+case the override is honored as written.
 
 Completion report (require-then-synthesize): every dispatched specialist MUST end with a structured completion report as its final message. The preamble's `REPORT_CONTRACT` injects this and the role prompts carry the per-role format (see `references/agent-report-contract.md`). Because child-agent honor is best-effort across harnesses, this is decision-shaping, not a hard block. When a specialist returns no usable report (it went idle, emitted only a bare ping, or its message was lost to a mid-run interjection), run `scripts/agent-report <intent_dir> --role <role>` to synthesize a deterministic filesystem-derived report so the handoff account always exists. Use the agent-authored report when present, the synthesized one otherwise.
 

package/skills/continuing/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: plastic-continuing
+description: >-
+  Use when the user says "continue", "resume", or "pick up where we left off", starts a new
+  session and wants to keep going, asks "what should I work on", or asks a where-was-I question
+  that never says "continue" (for example "where was I"). This is the front door for resuming
+  work: it dispatches to plastic-intent-continuing (a specific intent named to resume),
+  plastic-project-continuing (the default, general board landing), or
+  plastic-roadmap-continuing (a roadmap or delivery batch named to resume).
+user-invocable: true
+---
+
+# Continuing - the front door
+
+`plastic-continuing` is the front door for resuming work (ruling 96: continuing routes,
+starting does the lock plus resume plus work). It routes to exactly one of three skills and
+does nothing else: no ledger-resume, no dashboard render, no roadmap read happens here.
+
+## Route
+
+| Args / context | Route to |
+|---|---|
+| `--intent {id}`, or the user names one specific intent (by id or description) to resume | `plastic-intent-continuing` (intent route) |
+| `--roadmap {slug}`, or the user asks to continue/resume a roadmap or delivery batch | `plastic-roadmap-continuing` (roadmap route) |
+| bare "continue" / "resume" / no further target (default) | `plastic-project-continuing` (project route) |
+
+## Announce, then hand off
+
+State the chosen route in one line before delegating (this is the router's own "present state
+before any ask" - the router asks nothing itself). Example: "Routing to the project board (no
+specific intent or roadmap named)."
+
+Then hand off to the chosen skill. Do not inline any of the routed skill's own work here -
+that belongs to the routes.

package/skills/continuing/evals/evals.json

@@ -0,0 +1,91 @@
+{
+  "skill_name": "plastic-continuing",
+  "notes": "Intent 158a1. New bare front-door router restored per intent 96 (D8). Scopes: description triggering (1-5) and routing behavior (6-9), the latter checked as convention against SKILL.md's routing table.",
+  "results": {
+    "triggering": { "cases": 5, "passed": 5, "run": "2026-07-10, one subagent per case" },
+    "behavior": { "cases": 4, "passed": 4, "evidence": "convention checks against skills/continuing/SKILL.md's routing table" }
+  },
+  "evals": [
+    {
+      "id": 1, "scope": "triggering", "set": "train",
+      "prompt": "continue",
+      "expected_output": "Activates plastic-continuing (the bare 'continue' keyword is the router's documented trigger).",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-continuing", "observed": "plastic-continuing", "result": "pass" }
+      ]
+    },
+    {
+      "id": 2, "scope": "triggering", "set": "train",
+      "prompt": "resume where we left off",
+      "expected_output": "Activates plastic-continuing.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-continuing", "observed": "plastic-continuing", "result": "pass" }
+      ]
+    },
+    {
+      "id": 3, "scope": "triggering", "set": "validation",
+      "prompt": "pick up where we left off",
+      "expected_output": "Activates plastic-continuing.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-continuing", "observed": "plastic-continuing", "result": "pass" }
+      ]
+    },
+    {
+      "id": 4, "scope": "triggering", "set": "validation",
+      "prompt": "where was I",
+      "expected_output": "Activates plastic-continuing (indirect trigger: a continue request that never says 'continue').",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-continuing", "observed": "plastic-continuing", "result": "pass" }
+      ]
+    },
+    {
+      "id": 5, "scope": "triggering", "set": "validation",
+      "prompt": "continue the for-loop in this function",
+      "expected_output": "Does NOT activate plastic-continuing. Near-miss: shares 'continue' but is a code-editing task.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE != plastic-continuing", "observed": "none", "result": "pass" }
+      ]
+    },
+    {
+      "id": 6, "scope": "behavior", "set": "train",
+      "prompt": "continue",
+      "expected_output": "Bare 'continue' with no further target dispatches to the project route (plastic-project-continuing), the routing table's default.",
+      "files": ["skills/continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "routing table's default row maps bare continue/resume/no target to plastic-project-continuing", "observed": "present", "result": "pass" }
+      ]
+    },
+    {
+      "id": 7, "scope": "behavior", "set": "train",
+      "prompt": "continue --intent 4a",
+      "expected_output": "Dispatches to the intent route (plastic-intent-continuing).",
+      "files": ["skills/continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "routing table maps --intent {id} to plastic-intent-continuing", "observed": "present", "result": "pass" }
+      ]
+    },
+    {
+      "id": 8, "scope": "behavior", "set": "validation",
+      "prompt": "resume the statusline-coloring intent",
+      "expected_output": "Dispatches to the intent route (plastic-intent-continuing): a specific intent named by description.",
+      "files": ["skills/continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "routing table maps a named specific intent (by id or description) to plastic-intent-continuing", "observed": "present", "result": "pass" }
+      ]
+    },
+    {
+      "id": 9, "scope": "behavior", "set": "validation",
+      "prompt": "continue the consistency-dividend roadmap",
+      "expected_output": "Dispatches to the roadmap route (plastic-roadmap-continuing).",
+      "files": ["skills/continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "routing table maps a named roadmap/delivery batch to plastic-roadmap-continuing", "observed": "present", "result": "pass" }
+      ]
+    }
+  ]
+}

package/skills/dashboard/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: plastic-dashboard
-description: Use when the user wants an overview of intents, asks "where are we", "what's next", "what should I work on", "show the dashboard", or invokes /plastic-dashboard. Renders a deterministic Value×Effort work cockpit as Markdown across the global store and all projects, and emits a machine-readable queue that auto mode consumes.
+description: Use when the user wants an overview of intents, asks "where are we", "what's next", "what should I work on", "show the dashboard", or invokes /plastic-dashboard. Renders the intent store(s) as Markdown prose, the global board as a narrative of work done, each project board as a short summary plus its most-valuable next work, and emits a machine-readable queue that auto mode consumes.
 user-invocable: false
 ---
 
 # Dashboard — Plastic Work Cockpit
 
 A deterministic overview of the intent store(s). It answers three questions at a glance:
-**where we are** (recently worked), **where we go next** (a Value×Effort matrix), and
+**where we are** (recently worked), **where we go next** (the most-valuable next work), and
 **how to conduct it** (a disposition per intent). The human-facing surface is **Markdown**,
 because the user's UI renders Markdown natively but collapses raw tool-call stdout.
 
@@ -19,7 +19,7 @@ state → byte-identical payload, regardless of model. Do NOT hand-summarize int
 
 - User invokes `/plastic-dashboard`
 - User asks "where are we", "what's next", "what should I work on", "show me the intents"
-- `plastic-intent-continuing` lands on the board on resume
+- `plastic-project-continuing` lands on the board on resume
 - `plastic-auto` reads `--json` to choose the next dispatchable intent
 
 ## Procedure (the Markdown board — default human surface)
@@ -34,9 +34,9 @@ ruby ~/.plastic/scripts/dashboard.rb [continue|project <slug>] --data
 - `project <slug>` → that **project** board payload (`mode: "project"`).
 
 The payload is read-only JSON. Global-board fields: `date`, `store_health`, `recently_worked`,
-`matrix` (`quick_win`/`next_big`/`defer`/`triage`/`research`, each a list of `{line, bullet, ...}`),
-`counts`, `projects`, `project_totals`. Project-board fields: `slug`, `store_health`,
-`description`, `recently_worked`, `matrix`, `counts`, `active`, `future`.
+`next_work` (a flat, rank-ordered list of `{id, intent, scope, lifecycle, value, disposition,
+flags, line}`), `counts`, `projects`, `project_totals`. Project-board fields: `slug`,
+`store_health`, `description`, `recently_worked`, `next_work`, `counts`, `active`, `future`.
 
 Each board load runs the scoped store check (`doctor --store <scope>`): the global board runs
 `--store global` and a project board runs `--store <slug>`. The result rides in the payload as
@@ -51,13 +51,16 @@ Templates live in this skill's `templates/` directory:
 `~/.claude/skills/plastic-dashboard/templates/dashboard-global.md` and
 `dashboard-project.md`.
 
-Fill mechanically — no rewriting, no re-sorting:
-- `{{a.b.count}}` → the integer (e.g. `matrix.quick_win.count` = that list's length).
+Fill mechanically, no rewriting, no re-sorting:
+- `{{a.b.count}}` → the integer (e.g. `counts.active` = that count).
 - `{{...lines}}` → join the list's `.line` strings with **real newlines** (one per line).
-  These lines are already glyph-led (the glyph is the bullet — never add `-`, never emit
-  `<br>`). If a matrix quadrant list is empty, render `_(none)_`.
+  These are ordinary prose lines, not glyph-led bullets: never add a Markdown `-` bullet,
+  never emit `<br>`. If a list is empty, render `_(none)_`.
+- `next_work.lines` → the most-valuable next work, already ranked; each line reads
+  `"<id> <intent, truncated>"`. Use each entry's `disposition`/`flags` fields when the prose
+  needs to say why an item is next.
 - `projects.lines` → one line per project:
-  `- **{slug}** — {description} · active {active} · done {done} · future {future} · last accessed {last_accessed_at[0,10]}`.
+  `- **{slug}**: {description}, active {active}, done {done}, future {future}, last accessed {last_accessed_at[0,10]}`.
 - Scalars (`{{date}}`, `{{slug}}`, `{{description}}`) → substitute verbatim.
 
 ### Step 3 — Present it (mandatory, every invocation)
@@ -112,7 +115,7 @@ a raw terminal. The Markdown board (`--data` + template) is the surface for the
 ## How classification works (deterministic)
 
 The script computes Effort/Value/Flags/Override/Caps; the agent never re-derives them.
-To explain or debug a quadrant assignment, read `references/classification.md`.
+To explain or debug a ranking or disposition, read `references/classification.md`.
 
 ## Eval
 
@@ -123,7 +126,7 @@ intentional change means the skill is broken.
 
 ## Notes
 
-- Quadrant lists are **not** Markdown `-` bullets — the glyph is the bullet (the boards are
-  UI-only and may evolve, so they need not be valid Markdown lists). Never emit `<br>`.
+- Board lines are ordinary prose, not a rigid grid: the boards are UI-only and may evolve,
+  so they need not be valid Markdown lists. Never emit `<br>`.
 - Clusters (Zettelkasten grouping in INDEX.md) are intentionally not rendered.
 - Additive: changes no core lifecycle, gate, or cycle logic.

package/skills/dashboard/references/classification.md

@@ -1,7 +1,7 @@
 # How Classification Works (Deterministic)
 
 The script (`dashboard.rb`) computes Effort/Value/Flags/Override/Caps deterministically;
-the agent never re-derives them. Read this to explain or debug a quadrant assignment.
+the agent never re-derives them. Read this to explain or debug a ranking or disposition.
 
 - **Effort** — small for `research`/`exploration`/`bugfix`, for already-scoped intents
   (plan/checklist exists), or a **branch id** (folgezettel depth ≥ 2, e.g. `4a`, `12b3`); big
@@ -16,7 +16,7 @@ the agent never re-derives them. Read this to explain or debug a quadrant assign
   the staleness threshold. All three kept low-noise by design.
 - **Override** — a `value: high|low` frontmatter field always wins (pre-stamped data, never
   model judgment at render time).
-- **Caps** — quadrant lists and the project board's `active`/`future` lists are capped at 8
-  entries plus a trailing "+N more" line; each entry's text is truncated to 120 characters
+- **Caps**: the next-work list and the project board's `active`/`future` lists are capped at
+  8 entries plus a trailing "+N more" line; each entry's text is truncated to 120 characters
   with a trailing ellipsis. Applies to the Markdown board only (the ASCII renderer has its own
   separate `CELL_CAP`).

package/skills/dashboard/templates/dashboard-global.md

@@ -1,31 +1,16 @@
-# 🧩 Plastic · Global Board — {{date}}
+# 🧩 Plastic · Global Board, {{date}}
 
-**Recently worked** · last 24h
+**Recently worked** (last 24h)
 {{recently_worked.lines}}
 
-## Where we go next · Value × Effort  *(global intents only)*
+## Where we are
 
-|  | Small effort | Big effort |
-|---|---|---|
-| **High value** | ⚡ **Quick win** · {{matrix.quick_win.count}} | ★ **Next big thing** · {{matrix.next_big.count}} |
-| **Low value** | → **Defer (agent)** · {{matrix.defer.count}} | ⚑ **Triage** · {{matrix.triage.count}} |
+{{counts.active}} intents active, {{counts.done}} done, {{counts.future}} queued for later.
 
-**⚡ Quick win** — small effort, high value
-{{matrix.quick_win.lines}}
-
-**★ Next big thing** — big effort, high value
-{{matrix.next_big.lines}}
-
-**→ Defer (agent)** — small effort, low value
-{{matrix.defer.lines}}
-
-**⚑ Triage** — big effort, low value
-{{matrix.triage.lines}}
-
-🔬 **Research → agent**
-{{matrix.research.lines}}
-
-## Projects · active {{project_totals.active}} · done {{project_totals.done}} · future {{project_totals.future}}
+## Projects, active {{project_totals.active}}, done {{project_totals.done}}, future {{project_totals.future}}
 {{projects.lines}}
 
+## Most-valuable next work
+{{next_work.lines}}
+
 **What would you like to work on next?** (type an **intent id**, a **project name**, or anything **new** you'd like to start)

package/skills/dashboard/templates/dashboard-project.md

@@ -1,33 +1,11 @@
-# 📦 {{slug}} · Project Board — {{date}}
+# 📦 {{slug}} · Project Board, {{date}}
 
 {{description}}
 
-**Recently worked** · last 24h
+**Recently worked** (last active work, last 24h)
 {{recently_worked.lines}}
 
-## Where we go next · Value × Effort
-
-|  | Small effort | Big effort |
-|---|---|---|
-| **High value** | ⚡ **Quick win** · {{matrix.quick_win.count}} | ★ **Next big thing** · {{matrix.next_big.count}} |
-| **Low value** | → **Defer (agent)** · {{matrix.defer.count}} | ⚑ **Triage** · {{matrix.triage.count}} |
-
-**⚡ Quick win** — small effort, high value
-{{matrix.quick_win.lines}}
-
-**★ Next big thing** — big effort, high value
-{{matrix.next_big.lines}}
-
-**→ Defer (agent)** — small effort, low value
-{{matrix.defer.lines}}
-
-**⚑ Triage** — big effort, low value
-{{matrix.triage.lines}}
-
-🔬 **Research → agent**
-{{matrix.research.lines}}
-
-## Intents · active {{counts.active}} · done {{counts.done}} · future {{counts.future}}
+## Intents, active {{counts.active}}, done {{counts.done}}, future {{counts.future}}
 
 **Active**
 {{active.lines}}
@@ -35,6 +13,9 @@
 **Future**
 {{future.lines}}
 
-**Legend** · ○ What ◔ Why ◑ How ◕ Exec ● Done · ⚡ quick win ★ big → defer ⚑ triage 🔬 research
+## Most-valuable next work
+{{next_work.lines}}
+
+**Legend** · ○ What ◔ Why ◑ How ◕ Exec ● Done
 
 **What would you like to work on next?** (type an **intent id**, or **global** to go back)

package/skills/doctor/SKILL.md

@@ -13,7 +13,7 @@ Doctor has three scopes. Pick the right one for the situation:
 | Scope | Flag | When it runs | States |
 |-------|------|--------------|--------|
 | Core check | `--core` | SessionStart hook (automatic), also available on demand | Binary: pass or error |
-| Store check | `--store [global\|<slug>]` | Dashboard load, `plastic-intent-continuing` | Three-state: pass / warn / fail |
+| Store check | `--store [global\|<slug>]` | Dashboard load, `plastic-project-continuing` | Three-state: pass / warn / fail |
 | Full check | (no flag) | After every update (automatic), or `/plastic-doctor` | Three-state: pass / warn / fail |
 
 ### `--core` (binary, manifest-backed)

package/skills/install/SKILL.md

@@ -1,13 +1,13 @@
 ---
 name: plastic-install
-description: 'Use when initializing Plastic globally (~/.plastic/) or locally in a project, or to re-install/repair a broken installation. Accepts channel flags (--alpha, --beta, --latest) to select release channel. First install defaults to --beta; reinstalls match the already-installed channel. Global install is recommended: it creates the global intent store as a git-backed repository. Local install creates .plastic/ in the current project for testing.'
+description: 'Use when initializing Plastic globally (~/.plastic/) or locally in a project, or to re-install/repair a broken installation. Accepts channel flags (--alpha, --beta, --latest) to select release channel. First install defaults to --latest (stable); reinstalls match the already-installed channel. Global install is recommended: it creates the global intent store as a git-backed repository. Local install creates .plastic/ in the current project for testing.'
 user-invocable: true
 ---
 
 # Install Plastic
 
-> **Recommended path:** for a first install, run `npx -y @zalom/plastic@beta install --claude`
-> in your shell (or `bunx -y @zalom/plastic@beta install --claude` if you use Bun). This skill
+> **Recommended path:** for a first install, run `npx -y @zalom/plastic@latest install --claude`
+> in your shell (or `bunx -y @zalom/plastic@latest install --claude` if you use Bun). This skill
 > exists to **re-install or repair** an existing setup from inside the agent, and to
 > drive interactive global configuration. Whenever this skill performs an install or
 > re-install, it **runs `/plastic-doctor` afterward** and reports the result.
@@ -16,7 +16,7 @@ user-invocable: true
 
 If Plastic is installed, derive `<channel>` from `~/.plastic/VERSION`: a version containing
 `-alpha` means `@alpha`, `-beta` means `@beta`, otherwise `@latest`. If not installed
-(first install), default to `@beta`. The user can always override with
+(first install), default to `@latest`. The user can always override with
 `--alpha` / `--beta` / `--latest`.
 
 ## Re-install / repair
@@ -35,18 +35,18 @@ Then **run `/plastic-doctor`** and report what it found.
 
 | Flag | Behavior |
 |------|----------|
-| `--latest` | Install from the stable channel |
-| `--beta` | Install from the beta channel (default on a first install) |
+| `--latest` | Install from the stable channel (default on a first install) |
+| `--beta` | Install from the beta channel |
 | `--alpha` | Install from the alpha channel |
 
 When invoked from within Claude Code (re-install or channel switch), the skill
 runs the appropriate npx command:
 
 ```bash
-# Stable
+# Stable (default on a first install)
 npx -y @zalom/plastic@latest install --claude
 
-# Beta (default on a first install)
+# Beta
 npx -y @zalom/plastic@beta install --claude
 
 # Alpha
@@ -68,10 +68,10 @@ Run `/plastic-install` with no arguments.
 Check if `~/.plastic/VERSION` exists.
 - If yes: announce "Plastic is already installed at ~/.plastic/. Run `/plastic-update` to
   sync core files, or use the re-install command above to repair in place."
-- If no: run the fresh install command (default `@beta`, or the channel the user named):
+- If no: run the fresh install command (default `@latest`, or the channel the user named):
 
 ```bash
-npx -y @zalom/plastic@beta install --claude
+npx -y @zalom/plastic@latest install --claude
 ```
 
 This single command, via `install.rb` (`bootstrap` + `distribute`), creates `store/`,

package/skills/intent-continuing/SKILL.md

@@ -1,61 +1,42 @@
 ---
 name: plastic-intent-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).'
+description: >-
+  Use when a specific intent is named to resume, by id or by description, or on `continuing
+  --intent {id}`. Reads that intent's savepoint ledger and hands off to plastic-intent-starting.
+  The general "continue" / new-session triggers belong to the plastic-continuing router, not
+  here, so a bare "continue" does not settle on this skill directly. 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).
 user-invocable: true
 ---
 
-# Continuing
+# Continuing (intent route)
 
-`plastic-intent-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).
+`plastic-intent-continuing` is the intent route of `plastic-continuing`. It resumes ONE
+specific intent by its savepoint ledger, then hands off to `plastic-intent-starting`. It does
+NOT land on a dashboard and does NOT execute work autonomously (that is `plastic-auto`); both
+of those are other routes' jobs.
 
 **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
+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]]).
+resumes the named intent. 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 and you want to resume work with the latest context
+- A specific intent is named to resume, by id or by description
+- `continuing --intent {id}`
 
 ## Determine Store
 
-1. **Global store** — `~/.plastic/INDEX.md` exists → global mode.
-2. **Local store** — a project store under `~/.plastic/projects/{slug}/` whose registered
+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.
+   named intent's store.
 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, non-optional). If the reply does not contain the filled Markdown,
-the user sees nothing — tool-call stdout and hook `additionalContext` are both invisible to
-them. `hook-continue` also emits a one-line `systemMessage` summary as a hook-owned fallback;
-treat it as a floor only, never as a substitute for presenting the full board here. 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
@@ -98,44 +79,21 @@ For that intent's directory:
    - "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:**
+5. **Announce, then hand off to `plastic-intent-starting`:**
    ```
-   Resuming intent [ID] — [name]
+   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)
-  a) Activate — start working on it now
-  b) Abandon — mark as abandoned
-  c) Defer to agent: implement | research | ideate
-  d) Auto — go fully autonomous (invokes plastic-auto)
-```
-
-When the user activates a future intent, move it to `## Active` in INDEX.md and auto-commit.
+   Hand off to `plastic-intent-starting`: it takes the lock, boards at this station, and is
+   where the single "auto or guided?" ask for the intent route lives, asked there exactly
+   once and never duplicated here. Its auto branch is the one that hands off to `plastic-auto`;
+   this skill never hands to `plastic-auto` directly.
 
 ## References
 
-- Read `references/context-management.md` for the full save/continue protocol and for
+- Read `references/context-management.md` for the save/continue protocol and for
   debugging the resume flow.