@zalom/plastic 1.0.0-alpha.20 → 1.0.0-alpha.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalom/plastic",
-  "version": "1.0.0-alpha.20",
+  "version": "1.0.0-alpha.21",
   "description": "Intent-driven idea development system for AI coding agents",
   "type": "module",
   "bin": {

package/scripts/doctor.rb

@@ -62,6 +62,7 @@ class Doctor
   def parse_args(argv)
     agent = "claude"
     help = false
+    core = false
 
     i = 0
     while i < argv.length
@@ -74,6 +75,9 @@ class Doctor
           $stderr.puts "Error: --agent requires one of: #{agents.keys.join(", ")}"
           exit 2
         end
+      when "--core"
+        core = true
+        i += 1
       when "--help", "-h"
         help = true
         i += 1
@@ -82,7 +86,7 @@ class Doctor
       end
     end
 
-    { agent: agent, help: help }
+    { agent: agent, help: help, core: core }
   end
 
   def show_help
@@ -95,6 +99,8 @@ class Doctor
 
       Options:
         --agent NAME    Agent to check: claude (default), codex, hermes
+        --core          Fast runtime-liveness check only (hooks, scripts, core files);
+                        skips the slow store/conventions/project inventory walks.
         -h, --help      Show this help
 
       Output:
@@ -903,6 +909,23 @@ class Doctor
     all_checks += check_project_stores
     all_checks += check_deprecations
 
+    summarize(all_checks, agent_key)
+  end
+
+  # Fast runtime-liveness check: only the plumbing that proves Plastic can
+  # operate (hooks, skills, scripts, core files). Skips the slow inventory
+  # walks (global store refs, per-intent conventions, project stores,
+  # deprecations) so it returns near-instantly. Used by `doctor.rb --core`.
+  def run_core_checks(agent_key)
+    all_checks = []
+    all_checks += check_agent_registration(agent_key)
+    all_checks += check_core_files(agent_key)
+
+    summarize(all_checks, agent_key)
+  end
+
+  # Roll a list of checks up into the standard result envelope.
+  def summarize(all_checks, agent_key)
     summary = { pass: 0, warn: 0, fail: 0, total: all_checks.size }
     all_checks.each { |c| summary[c[:status].to_sym] += 1 }
 
@@ -934,7 +957,7 @@ class Doctor
       exit 0
     end
 
-    result = run_checks(flags[:agent])
+    result = flags[:core] ? run_core_checks(flags[:agent]) : run_checks(flags[:agent])
 
     puts JSON.pretty_generate(result)
 

package/skills/continuing/SKILL.md

@@ -1,120 +1,129 @@
 ---
 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.
+description: Use when the user says "continue", "resume", or "pick up where we left off", or when starting a new session. Boots Plastic — runtime health check, loads core context + store/project state, prints version + statusline, and lands on the right dashboard — then presents choices. Does not drive work autonomously (that is plastic-auto).
 ---
 
 # Continuing
 
+`plastic-continuing` is a deterministic **boot orchestrator**. It loads and presents choices,
+then stops. It does NOT execute work autonomously (that is `plastic-auto`) and does NOT render
+the dashboard itself (it only invokes it).
+
 ## 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 with an existing Plastic store
 
 ## Determine Store
 
-1. Check `~/.plastic/INDEX.md` → global mode
-2. 
+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.
+   Project detection happens in boot step 2 below; this just records that a local store is
+   in play.
 3. If neither exists → announce "No Plastic store found. Run /plastic-install."
 
-## Workflow
+## Boot Sequence (run in this fixed order)
 
-### 0. Render the dashboard (overview)
-For the "where are we / what's next" overview, run the deterministic dashboard and show
-its output verbatim instead of hand-summarizing intents:
+### 1. Core doctor (health first)
+Run the fast runtime-liveness check synchronously (it returns in well under a second):
 
 ```bash
-ruby ~/.plastic/scripts/dashboard.rb continue
-```
-
-This is the uniform, model-agnostic cockpit (active + last touched, then the Value×Effort
-matrix). Then continue with the steps below to actually resume a specific intent. See the
-`plastic-dashboard` skill for how to read the matrix.
-
-### 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]
+ruby ~/.plastic/scripts/doctor.rb --core
 ```
 
-**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):
+Print one compact health line:
+- All pass → `Plastic core: healthy`
+- Otherwise → `Plastic core: issues` followed by the failing checks (name + message).
+
+This runs first so a broken runtime (missing hooks, scripts, core files) surfaces before any
+state is loaded on top of it. For a full diagnosis, point the user at `/plastic-doctor`.
+
+### 2. Load core (context + state)
+- Prime `PLASTIC.md` and the harness docs so the conventions are in mind.
+- Load live state:
+  - Read the active store `INDEX.md` (`## Active`, `## Future`).
+  - Read `~/.plastic/projects.yml`.
+  - **Detect the current project** by matching CWD against registered project paths.
+  - If in a project: load that project's `INDEX.md`; load the governing intent (from
+    `parent` in projects.yml) and the tactical intents from
+    `~/.plastic/projects/{slug}/store/`.
+
+### 3. Version + statusline
+- Print the current Plastic version (from `~/.plastic/VERSION`).
+- Set the statusline.
+
+### 4. Dashboard
+Invoke the dashboard. Rendering belongs to the dashboard skill, not here — only invoke:
+- Project loaded → `ruby ~/.plastic/scripts/dashboard.rb project <slug>`
+- Otherwise → `ruby ~/.plastic/scripts/dashboard.rb continue`
+
+Show its output verbatim. See `plastic-dashboard` for how to read the matrix.
+
+### 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.
-
-### 6. Priority Order
-
-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
+When the user activates a future intent, move it to `## Active` in INDEX.md and auto-commit.
 
 ## References
 
-- Read `references/context-management.md` for the full save/continue protocol when resuming from a savepoint or when the resume flow needs debugging
+- Read `references/context-management.md` for the full save/continue protocol and for
+  debugging the resume flow.

package/skills/continuing/evals/evals.json

@@ -0,0 +1,136 @@
+{
+  "skill_name": "plastic-continuing",
+  "notes": "Intent 36. Scopes: description triggering (1-8) and behavior/convention compliance of the rewritten boot orchestrator (9-14). Triggering assertions follow the plastic-auto eval style (one subagent router per case). Behavior assertions are convention checks against the rewritten SKILL.md.",
+  "results": {
+    "triggering": { "cases": 8, "passed": 8, "run": "2026-06-16, one subagent per case" },
+    "behavior": { "cases": 6, "passed": 6, "evidence": "convention checks against skills/continuing/SKILL.md after the intent-36 rewrite; doctor --core verified at 0.07s with 9 liveness checks and full doctor unchanged at 30 checks" }
+  },
+  "evals": [
+    {
+      "id": 1, "scope": "triggering", "set": "train",
+      "prompt": "continue",
+      "expected_output": "Activates plastic-continuing (the bare 'continue' keyword is the 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 in this project",
+      "expected_output": "Activates plastic-continuing.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-continuing", "observed": "plastic-continuing", "result": "pass" }
+      ]
+    },
+    {
+      "id": 4, "scope": "triggering", "set": "train",
+      "prompt": "boot plastic and show me where things stand",
+      "expected_output": "Activates plastic-continuing (boot + present state is the skill's purpose).",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-continuing", "observed": "plastic-continuing", "result": "pass" }
+      ]
+    },
+    {
+      "id": 5, "scope": "triggering", "set": "train",
+      "prompt": "continue delivering this intent autonomously, don't ask me",
+      "expected_output": "Does NOT settle on plastic-continuing for execution. Shares 'continue' but the autonomous-delivery intent routes to plastic-auto.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE == plastic-auto", "observed": "plastic-auto", "result": "pass" }
+      ]
+    },
+    {
+      "id": 6, "scope": "triggering", "set": "validation",
+      "prompt": "continue the for-loop to the next iteration 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": 7, "scope": "triggering", "set": "train",
+      "prompt": "resume the paused background download",
+      "expected_output": "Does NOT activate plastic-continuing. Near-miss: shares 'resume' but is unrelated to Plastic sessions.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE != plastic-continuing", "observed": "none", "result": "pass" }
+      ]
+    },
+    {
+      "id": 8, "scope": "triggering", "set": "validation",
+      "prompt": "what's the dashboard look like right now",
+      "expected_output": "May activate plastic-dashboard rather than plastic-continuing; an overview request without 'continue/resume' is a dashboard task.",
+      "files": [],
+      "assertions": [
+        { "type": "code", "check": "router CHOICE != plastic-continuing", "observed": "plastic-dashboard", "result": "pass" }
+      ]
+    },
+    {
+      "id": 9, "scope": "behavior", "set": "train",
+      "prompt": "Does the skill document the four-step boot sequence in the fixed order?",
+      "expected_output": "SKILL.md lists, in order: (1) core doctor, (2) load core, (3) version + statusline, (4) dashboard.",
+      "files": ["skills/continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "boot steps appear in order doctor -> load core -> version/statusline -> dashboard", "observed": "headings '### 1. Core doctor', '### 2. Load core', '### 3. Version + statusline', '### 4. Dashboard'", "result": "pass" }
+      ]
+    },
+    {
+      "id": 10, "scope": "behavior", "set": "train",
+      "prompt": "Does step 1 run the fast core health check synchronously?",
+      "expected_output": "Step 1 invokes `doctor.rb --core` and prints a single health line.",
+      "files": ["skills/continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "SKILL.md contains 'doctor.rb --core' and a 'Plastic core: healthy' health line", "observed": "present in '### 1. Core doctor'", "result": "pass" }
+      ]
+    },
+    {
+      "id": 11, "scope": "behavior", "set": "train",
+      "prompt": "Is dashboard selection project-aware?",
+      "expected_output": "Project loaded -> `dashboard.rb project <slug>`; otherwise -> `dashboard.rb continue`. Skill only invokes, does not render.",
+      "files": ["skills/continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "both dashboard invocations present and gated on project detection", "observed": "'dashboard.rb project <slug>' and 'dashboard.rb continue' in '### 4. Dashboard'", "result": "pass" }
+      ]
+    },
+    {
+      "id": 12, "scope": "behavior", "set": "validation",
+      "prompt": "Is ledger-resume conditional and ledger-driven?",
+      "expected_output": "Resume fires only when a specific intent is named; reads savepoint.md last line as stage, verifies the stage file, rebuilds on drift, derives next step from first unchecked checklist item.",
+      "files": ["skills/continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "Conditional Ledger-Resume section reads last ledger line, verifies stage file, calls rebuild_savepoint on drift, uses first unchecked checklist item", "observed": "all four present in 'Conditional Ledger-Resume'", "result": "pass" }
+      ]
+    },
+    {
+      "id": 13, "scope": "behavior", "set": "validation",
+      "prompt": "Are the stale prose-savepoint fields gone?",
+      "expected_output": "No 'In progress' / 'Blockers' fields read from a prose savepoint remain; the ledger model is used instead.",
+      "files": ["skills/continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "no prose-savepoint announce template (In progress / Blockers from prose)", "observed": "absent; announce uses Stage/Next step/Context/Drift derived from ledger + checklist", "result": "pass" }
+      ]
+    },
+    {
+      "id": 14, "scope": "behavior", "set": "validation",
+      "prompt": "Is the 'Determine Store' local-store gap filled?",
+      "expected_output": "Step 2 of Determine Store describes local/project-store detection (no empty step).",
+      "files": ["skills/continuing/SKILL.md"],
+      "assertions": [
+        { "type": "convention", "check": "Determine Store step 2 documents local/project store detection via projects.yml + CWD match", "observed": "filled", "result": "pass" }
+      ]
+    }
+  ]
+}