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

package/package.json

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

package/scripts/dashboard.rb

@@ -87,6 +87,22 @@ def intent_dirs(store)
      .sort
 end
 
+# Last-accessed timestamp: the timestamp of the last ISO8601 line in the
+# deterministic savepoint ledger (intent 34); falls back to the created date.
+ISO8601_RE = /\A\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z\b/
+
+def last_accessed_at(dir, created)
+  sp = File.join(dir, "savepoint.md")
+  if File.exist?(sp)
+    File.readlines(sp).reverse_each do |line|
+      m = line.strip.match(ISO8601_RE)
+      return m[0] if m
+    end
+  end
+  return "#{created}T00:00:00Z" if created && !created.empty?
+  ""
+end
+
 # Parse one intent directory into a raw record.
 def parse_intent(store_info, dir_name, status_index)
   dir = File.join(store_info[:store], dir_name)
@@ -124,6 +140,7 @@ def parse_intent(store_info, dir_name, status_index)
     savepoint: has.("savepoint.md"),
     checklist_partial: has.("checklist.md") && checklist_partially_done?(File.join(dir, "checklist.md")),
     body_has_context: body.include?("## Context"),
+    last_accessed_at: last_accessed_at(dir, (fm["created"].to_s rescue "")),
   }
 end
 
@@ -155,7 +172,9 @@ def load_all
       done_ids[[rec[:scope], rec[:id]]] = true if rec[:status] == "completed"
     end
   end
-  [all, done_ids]
+  referenced = {}
+  all.each { |r| r[:sources].each { |s| referenced[[r[:scope], s]] = true } }
+  [all, done_ids, referenced]
 end
 
 # ---------------------------------------------------------------------------
@@ -200,19 +219,22 @@ end
 # Value -> :high | :low (explicit frontmatter field wins).
 # High is deliberately rare: an explicit stamp, or a human-authored root idea that has
 # already spawned follow-on work (chain non-empty) — i.e. a strategic theme the user owns.
-def value_of(rec)
+def value_of(rec, referenced = {})
   case rec[:value_field]
   when "high" then return :high
   when "low"  then return :low
   end
-  return :high if rec[:author] == "human" && root_intent?(rec[:id]) && !rec[:chain].empty?
+  return :high if rec[:author] == "human" && root_intent?(rec[:id])
+  return :high unless rec[:chain].empty?
+  return :high if referenced[[rec[:scope], rec[:id]]]
   :low
 end
 
 def flags_of(rec, done_ids)
   flags = []
   flags << "in-progress" if rec[:savepoint] || rec[:checklist_partial]
-  if !rec[:sources].empty? && rec[:sources].any? { |s| done_ids[[rec[:scope], s]] }
+  if rec[:status] == "future" && !rec[:sources].empty? &&
+     rec[:sources].all? { |s| done_ids[[rec[:scope], s]] }
     flags << "unblocked"
   end
   age = stale_age(rec)
@@ -244,9 +266,9 @@ def disposition_of(type, quadrant)
   end
 end
 
-def classify(rec, done_ids)
+def classify(rec, done_ids, referenced = {})
   type = intent_type(rec)
-  value = value_of(rec)
+  value = value_of(rec, referenced)
   effort = effort_of(rec, type)
   quadrant = QUADRANTS[[value, effort]]
   disposition = disposition_of(type, quadrant)
@@ -280,6 +302,12 @@ LIFECYCLE_GLYPH = { "what" => "○", "why" => "◔", "how" => "◑", "exec" => "
 DISPOSITION_GLYPH = { "drive" => "▸", "defer" => "⇢", "research" => "⊙", "triage" => "⚑" }.freeze
 LEGEND = "legend  ○ What ◔ Why ◑ How ◕ Exec ● Done │ ▸drive ⇢defer ⊙research ⚑triage │ ⇡unblocked"
 
+# Markdown board glyphs (intent 37). Quadrant signatures + per-line bullets.
+QUADRANT_BULLET = {
+  "quick_win" => "⚡", "next_big" => "★", "defer" => "→", "triage" => "⚑",
+}.freeze
+STATUS_GLYPH = { "active" => "◑", "completed" => "●", "future" => "○" }.freeze
+
 # ---------------------------------------------------------------------------
 # Rendering helpers
 # ---------------------------------------------------------------------------
@@ -421,6 +449,133 @@ def render_all(records)
   out.join("\n") + "\n"
 end
 
+# ---------------------------------------------------------------------------
+# Markdown-board data payload (intent 37) — heavy side; the skill fills a
+# Markdown template from this and presents it. Deterministic, golden-tested.
+# ---------------------------------------------------------------------------
+
+# Descending sort key for an ISO8601 / date string without reversing arrays.
+def invert_ts(ts)
+  ts.to_s.ljust(20).chars.map { |c| 255 - c.ord }
+end
+
+def within_24h?(rec)
+  ts = rec[:last_accessed_at]
+  return false if ts.nil? || ts.empty?
+  d = (Date.parse(ts[0, 10]) rescue nil)
+  d && d >= (today - 1)
+end
+
+def worked_row(rec, project_scope)
+  glyph = STATUS_GLYPH[rec[:status]]
+  proj = rec[:scope] == "global" ? "global" : rec[:scope].sub("project:", "")
+  status_word = rec[:status] == "completed" ? "done" : rec[:status]
+  prefix = project_scope ? "" : "#{proj} | "
+  {
+    id: rec[:id], status: rec[:status], glyph: glyph,
+    last_accessed_at: rec[:last_accessed_at],
+    line: "#{glyph} #{prefix}#{status_word}: #{rec[:id]} #{rec[:intent]}".strip,
+  }
+end
+
+def recently_worked(records, project_scope: nil)
+  pool = records.select do |r|
+    %w[active completed].include?(r[:status]) && within_24h?(r) &&
+      (project_scope.nil? || r[:scope] == project_scope)
+  end
+  ordered = pool.sort_by { |r| [r[:status] == "active" ? 0 : 1, invert_ts(r[:last_accessed_at])] }
+  ordered = ordered.first(5) if ordered.size > 15
+  ordered.map { |r| worked_row(r, project_scope) }
+end
+
+def intent_line(rec, bullet)
+  note = rec[:status] == "active" ? " (#{rec[:lifecycle].to_s.capitalize})" : ""
+  { id: rec[:id], intent: rec[:intent], created: rec[:created], bullet: bullet,
+    scope: rec[:scope], line: "#{bullet} #{rec[:id]} #{rec[:intent]}#{note}".rstrip }
+end
+
+def matrix_data(records)
+  cells = { "quick_win" => [], "next_big" => [], "defer" => [], "triage" => [] }
+  research = []
+  records.each do |r|
+    if %w[research exploration].include?(r[:type]) then research << r
+    else cells[r[:quadrant]] << r end
+  end
+  by_created_desc = ->(list) { list.sort_by { |r| invert_ts(r[:created]) } }
+  out = {}
+  cells.each { |q, list| out[q] = by_created_desc.call(list).map { |r| intent_line(r, QUADRANT_BULLET[q]) } }
+  out["research"] = by_created_desc.call(research).map { |r| intent_line(r, "🔬") }
+  out
+end
+
+def short_description(scope)
+  return "" unless scope.start_with?("project:")
+  slug = scope.sub("project:", "")
+  agents = File.join(PLASTIC_HOME, "projects", slug, "AGENTS.md")
+  if File.exist?(agents)
+    File.readlines(agents).each do |l|
+      t = l.strip
+      next if t.empty? || t.start_with?("#", ">")
+      return t[0, 60]
+    end
+  end
+  slug
+end
+
+def project_summaries(records)
+  scopes = records.map { |r| r[:scope] }.select { |s| s.start_with?("project:") }.uniq
+  rows = scopes.map do |scope|
+    scoped = records.select { |r| r[:scope] == scope }
+    {
+      slug: scope.sub("project:", ""),
+      description: short_description(scope),
+      active: scoped.count { |r| r[:status] == "active" },
+      done: scoped.count { |r| r[:status] == "completed" },
+      future: scoped.count { |r| r[:status] == "future" },
+      last_accessed_at: scoped.map { |r| r[:last_accessed_at] }.reject(&:empty?).max.to_s,
+    }
+  end
+  rows.sort_by { |r| invert_ts(r[:last_accessed_at]) }.first(5)
+end
+
+def counts_of(records)
+  { active: records.count { |r| r[:status] == "active" },
+    done: records.count { |r| r[:status] == "completed" },
+    future: records.count { |r| r[:status] == "future" } }
+end
+
+def render_data_global(records)
+  global = records.select { |r| r[:scope] == "global" }
+  matrix_pool = global.select { |r| actionable?(r) && r[:status] != "active" }
+  projs = project_summaries(records)
+  { mode: "global", date: today.to_s,
+    recently_worked: recently_worked(records),
+    matrix: matrix_data(matrix_pool),
+    counts: counts_of(global),
+    projects: projs,
+    project_totals: {
+      active: projs.sum { |p| p[:active] }, done: projs.sum { |p| p[:done] },
+      future: projs.sum { |p| p[:future] }
+    } }
+end
+
+def render_data_project(records, slug)
+  scope = "project:#{slug}"
+  scoped = records.select { |r| r[:scope] == scope }
+  matrix_pool = scoped.select { |r| r[:status] == "future" }
+  { mode: "project", date: today.to_s, slug: slug,
+    description: short_description(scope),
+    recently_worked: recently_worked(records, project_scope: scope),
+    matrix: matrix_data(matrix_pool),
+    counts: counts_of(scoped),
+    active: scoped.select { |r| r[:status] == "active" }
+                  .sort_by { |r| invert_ts(r[:last_accessed_at]) }
+                  .map { |r| intent_line(r, STATUS_GLYPH["active"]) },
+    future: scoped.select { |r| r[:status] == "future" }
+                  .sort_by { |r| invert_ts(r[:created]) }
+                  .map { |r| intent_line(r, STATUS_GLYPH["future"]) } }
+end
+
 # ---------------------------------------------------------------------------
 # JSON renderer (agent / auto-mode contract)
 # ---------------------------------------------------------------------------
@@ -448,11 +603,18 @@ end
 
 def main(argv)
   json = argv.delete("--json")
+  data = argv.delete("--data")
   mode = argv.shift || "continue"
   slug = argv.shift
 
-  raw, done_ids = load_all
-  records = raw.map { |r| classify(r, done_ids) }
+  raw, done_ids, referenced = load_all
+  records = raw.map { |r| classify(r, done_ids, referenced) }
+
+  if data
+    payload = mode == "project" ? render_data_project(records, slug) : render_data_global(records)
+    puts JSON.pretty_generate(payload)
+    return 0
+  end
 
   if json
     subset = mode == "project" ? records.select { |r| r[:scope] == "project:#{slug}" } : records

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,131 @@
 ---
 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
+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.
+
+### 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" }
+      ]
+    }
+  ]
+}

package/skills/dashboard/SKILL.md

@@ -1,65 +1,78 @@
 ---
 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 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 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.
 ---
 
 # Dashboard — Plastic Work Cockpit
 
-A deterministic, template-driven overview of the intent store(s). It answers three
-questions at a glance — **where we are** (active + last touched), **where we go next**
-(a Value×Effort matrix), and **how to conduct it** (a disposition verb per intent) — and
-emits a JSON manifest that `plastic-auto` reads to pick the next dispatchable intent.
+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
+**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.
 
-The script does the rendering. The LLM is **never** in the rendering path: same store
-state → byte-identical output, regardless of model. Do not hand-summarize intents when
-this skill applies — run the script and show its output verbatim.
+The script does all the data work. The agent fills a Markdown template from the script's
+payload with near-zero reasoning and **presents the filled board in its reply**. Same store
+state → byte-identical payload, regardless of model. Do NOT hand-summarize intents.
 
 ## When to Use
 
 - User invokes `/plastic-dashboard`
 - User asks "where are we", "what's next", "what should I work on", "show me the intents"
-- `plastic-continuing` embeds the `continue` view on resume
+- `plastic-continuing` lands on the board on resume
 - `plastic-auto` reads `--json` to choose the next dispatchable intent
 
-## Procedure
+## Procedure (the Markdown board — default human surface)
 
-### Step 1 — Run the script
+### Step 1 — Get the data payload
 
 ```bash
-ruby ~/.plastic/scripts/dashboard.rb [continue|project <slug>|all] [--json]
+ruby ~/.plastic/scripts/dashboard.rb [continue|project <slug>] --data
 ```
 
-| Mode | Shows |
-|------|-------|
-| `continue` (default) | Cross-scope: active + last touched, then the Value×Effort matrix for all scopes |
-| `project <slug>` | One project: active line + its Value×Effort matrix |
-| `all` | Per-scope roll-up summary |
-| `--json` | The auto-mode manifest (any mode); machine-readable, not for humans |
+- `continue` (default) → the **global** board payload (`mode: "global"`).
+- `project <slug>` → that **project** board payload (`mode: "project"`).
 
-The script is **read-only**. Print its stdout verbatim — do not reformat, re-sort, or
-re-summarize. That is what keeps the output uniform.
+The payload is read-only JSON. Global-board fields: `date`, `recently_worked`, `matrix`
+(`quick_win`/`next_big`/`defer`/`triage`/`research`, each a list of `{line, bullet, ...}`),
+`counts`, `projects`, `project_totals`. Project-board fields: `slug`, `description`,
+`recently_worked`, `matrix`, `counts`, `active`, `future`.
 
-### Step 2 — Read the matrix
+### Step 2 — Fill the matching template
 
-```
-                 small effort          big effort
-   high value    QUICK WIN             ★ NEXT BIG THING
-   low value     DEFER → agent         TRIAGE / question
-   (type=research/exploration → RESEARCH band, regardless of quadrant)
-```
+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).
+- `{{...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)_`.
+- `projects.lines` → one line per project:
+  `- **{slug}** — {description} · active {active} · done {done} · future {future} · last accessed {last_accessed_at[0,10]}`.
+- Scalars (`{{date}}`, `{{slug}}`, `{{description}}`) → substitute verbatim.
 
-Disposition verbs: `▸ drive` (human leads), `⇢ defer` (agent knocks off),
-`⊙ research` (research/explore agent), `⚑ triage` (human review / maybe abandon).
-Flags: `⇡ unblocked` (a dependency just completed), `(Nd)` stale age.
+### Step 3 — Present it (mandatory, every invocation)
 
-### Step 3 — Act on it
+**Paste the filled Markdown into your reply.** This is non-optional: the board only reaches
+the user when it is in the chat reply, not in tool-call stdout. Never describe the board
+instead of showing it.
 
-- **★ Next big thing** and `▸ drive` / `⚑ triage` items → the human leads (brainstorm → plan → exec).
-- `⇢ defer` and `⊙ research` items → dispatchable to agents.
-- In auto mode, read `--json` and work `dispatchable_queue` in `rank` order; leave
-  `human_only` for the user.
+### Step 4 — Entry flow (the board is the menu)
 
-## JSON contract
+The board lists everything; the user navigates by free prose (no capped picker):
+- On the **global** board, the user replies with an **intent id** (work it), a **project
+  name** (re-run `project <slug> --data` and present that board), or **"new"** (start a new
+  intent in global via `plastic-creating-intent`).
+- On a **project** board, the user replies with an **intent id**, or **"global"** to return.
+
+## Auto-mode contract (`--json`)
+
+`plastic-auto` consumes a separate machine-readable manifest (unchanged):
+
+```bash
+ruby ~/.plastic/scripts/dashboard.rb [continue|project <slug>|all] --json
+```
 
 ```json
 { "generated_for": "auto-mode", "scope": "<scope|all>",
@@ -68,25 +81,34 @@ Flags: `⇡ unblocked` (a dependency just completed), `(Nd)` stale age.
   "human_only": ["<id>", "..."] }
 ```
 
+Work `dispatchable_queue` in `rank` order (`defer`/`research`); leave `human_only` for the user.
+
+## Text modes (terminal / legacy)
+
+`dashboard.rb [continue|project <slug>|all]` with no flag still prints the ASCII cockpit for
+a raw terminal. The Markdown board (`--data` + template) is the surface for the chat UI.
+
 ## How classification works (deterministic)
 
 - **Effort** — small for `research`/`exploration`/`bugfix`, for already-scoped intents
   (plan/checklist exists), or deep refinement branches; big otherwise.
-- **Value** — high only for an explicit `value: high` frontmatter field, or a
-  human-authored root intent that has spawned follow-on work (`chain` non-empty); low otherwise.
-- **Override** — a `value: high|normal|low` field in an intent's frontmatter wins. This is
-  the only place model judgment enters, and only as pre-stamped data (never at render time).
+- **Value → high** when any of: explicit `value: high`; a human-authored **root** intent; an
+  intent with a non-empty `chain`; or an intent that is a `source` of ≥1 other intent. Else low.
+- **Flags** — `unblocked` only when a **future** intent has **all** its `sources` done;
+  `stale` only on future intents past the staleness threshold. Both kept low-noise by design.
+- **Override** — a `value: high|low` frontmatter field always wins (pre-stamped data, never
+  model judgment at render time).
 
 ## Eval
 
-This skill's eval is **render the template**: run the engine against the test fixture
-store and assert byte-identical text + JSON output against the golden snapshots in
-`test/fixtures/dashboard/`. See `test/dashboard_test.rb`. If output drifts from the
-golden files without an intentional template change, the skill is broken.
+The eval is the payload + golden snapshots: run the engine against the fixture store and
+assert the `--data` payload shape/sorting/classification and the byte-identical `--json` +
+text goldens in `test/fixtures/dashboard/`. See `test/dashboard_test.rb`. Drift without an
+intentional change means the skill is broken.
 
 ## Notes
 
-- Clusters (Zettelkasten grouping in INDEX.md) are intentionally **not** rendered — they
-  are orthogonal to "what to work on next."
-- Glyphs are monochrome Unicode (no emoji); they render in standard terminal emulators.
-- This is additive: it changes no core lifecycle, gate, or cycle logic.
+- 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>`.
+- Clusters (Zettelkasten grouping in INDEX.md) are intentionally not rendered.
+- Additive: changes no core lifecycle, gate, or cycle logic.

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

@@ -0,0 +1,31 @@
+# 🧩 Plastic · Global Board — {{date}}
+
+**Recently worked** · last 24h
+{{recently_worked.lines}}
+
+## Where we go next · Value × Effort  *(global intents only)*
+
+|  | 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}}
+
+## Projects · active {{project_totals.active}} · done {{project_totals.done}} · future {{project_totals.future}}
+{{projects.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

@@ -0,0 +1,40 @@
+# 📦 {{slug}} · Project Board — {{date}}
+
+{{description}}
+
+**Recently worked** · 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}}
+
+**Active**
+{{active.lines}}
+
+**Future**
+{{future.lines}}
+
+**Legend** · ○ What ◔ Why ◑ How ◕ Exec ● Done · ⚡ quick win ★ big → defer ⚑ triage 🔬 research
+
+**What would you like to work on next?** (type an **intent id**, or **global** to go back)