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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalom/plastic",
-  "version": "1.0.0-alpha.21",
+  "version": "1.0.0-alpha.23",
   "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/hook-session-start

@@ -7,6 +7,8 @@ require "json"
 require "date"
 require "yaml"
 require_relative "lib/bridge"
+require_relative "lib/boot_banner"
+require_relative "doctor"
 
 index_path, store_root, mode, plugin_root = ARGV
 exit 0 unless index_path && store_root && mode
@@ -172,6 +174,18 @@ if File.exist?(cache_file)
   end
 end
 
+# --- Run core health in-process (intent 36a) ---
+# Reuse Doctor's own --core checks so there is one source of truth for "core
+# health" (no second process spawn, no duplicated check list). Never blocks the
+# session: any failure or exception degrades to a banner and we continue.
+
+core_health = begin
+  Doctor.new(plastic_home: store_root).run_core_checks("claude")
+rescue
+  nil
+end
+core_banner = BootBanner.render(health: core_health, version: current_version)
+
 # --- Assemble session context ---
 
 all_active = active + project_active
@@ -184,6 +198,12 @@ all_future = future + project_future
 
 parts = []
 
+# Boot banner first: every session start surfaces that Plastic loaded, with the
+# version (clean) or the first failing core check (degraded). Owned by the hook
+# so it runs by construction — the plastic-continuing skill no longer does this.
+parts << core_banner
+parts << ""
+
 if plastic_md
   # Conventions always loaded first
   parts << plastic_md

package/scripts/lib/boot_banner.rb

@@ -0,0 +1,36 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Renders the SessionStart boot banner from a core-health result (intent 36a).
+#
+# Pure and dependency-injected: it takes the health hash (the return value of
+# Doctor#run_core_checks) and the version string, and returns a single banner
+# line. No I/O, no globals, no ENV — so it is unit-testable in isolation while
+# the hook feeds it real data.
+module BootBanner
+  module_function
+
+  # health: the Hash returned by Doctor#run_core_checks, or nil if the check
+  #         itself raised (degraded to an error banner).
+  # version: the installed Plastic version string, or nil.
+  def render(health:, version:)
+    return "Plastic Core: health check error — run /plastic-doctor" if health.nil?
+
+    if health[:status] == "pass"
+      "Plastic Core loaded — v#{version || "unknown"}"
+    else
+      bad = first_problem(health[:checks])
+      if bad
+        "Plastic Core loaded with issues — #{bad[:name]}: #{bad[:message]} — run /plastic-doctor"
+      else
+        "Plastic Core loaded with issues — run /plastic-doctor"
+      end
+    end
+  end
+
+  # First failing check, else first warning, else nil.
+  def first_problem(checks)
+    checks = checks || []
+    checks.find { |c| c[:status] == "fail" } || checks.find { |c| c[:status] == "warn" }
+  end
+end

package/skills/continuing/SKILL.md

@@ -1,64 +1,44 @@
 ---
 name: plastic-continuing
-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).
+description: Use when the user says "continue", "resume", or "pick up where we left off", or when starting a new session. Continues work with the latest project context: lands on the right dashboard, then presents choices. Boot (health check, core context, version, statusline) is owned by the SessionStart hook, not this skill. Does not drive work autonomously (that is plastic-auto).
 ---
 
 # Continuing
 
-`plastic-continuing` 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).
+`plastic-continuing` continues work. It presents the latest state via the dashboard and offers
+choices, then stops. It does NOT execute work autonomously (that is `plastic-auto`) and does
+NOT render the dashboard itself (it only invokes it).
+
+**Boot is not this skill's job.** The `hook-session-start` hook already runs by construction on
+every session start: it runs the core health check (`doctor --core`), primes `PLASTIC.md` +
+store/project state, and prints the `Plastic Core loaded — v{version}` banner. The
+`plastic-statusline` hook sets the statusline. So by the time this skill runs, core is loaded
+and healthy (or the banner already warned otherwise). This skill picks up from there and
+continues work. This is the seam future continue-flags build on (see [[39]]).
 
 ## When to Use
 - UserPromptSubmit hook detects "continue" (automatic)
 - User says "continue", "resume", or "pick up where we left off"
-- Starting a new session with an existing Plastic store
+- Starting a new session and you want to resume work with the latest context
 
 ## Determine Store
 
 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.
+   The SessionStart hook already detects this; here you only need the slug to scope the
+   dashboard.
 3. If neither exists → announce "No Plastic store found. Run /plastic-install."
 
-## Boot Sequence (run in this fixed order)
-
-### 1. Core doctor (health first)
-Run the fast runtime-liveness check synchronously (it returns in well under a second):
+## Continue (present the dashboard)
 
-```bash
-ruby ~/.plastic/scripts/doctor.rb --core
-```
+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`
 
-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.
+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

package/skills/continuing/evals/evals.json

@@ -1,6 +1,6 @@
 {
   "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.",
+  "notes": "Intent 36, updated for 36a (boot moved into hook-session-start; the skill is now work-continuation only). Scopes: description triggering (1-8) and behavior/convention compliance of the work-continuation skill (9-14). Triggering assertions follow the plastic-auto eval style (one subagent router per case). Behavior assertions are convention checks against the 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" }
@@ -36,7 +36,7 @@
     {
       "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).",
+      "expected_output": "Activates plastic-continuing (continuing work + presenting state is the skill's purpose; boot itself is hook-owned).",
       "files": [],
       "assertions": [
         { "type": "code", "check": "router CHOICE == plastic-continuing", "observed": "plastic-continuing", "result": "pass" }
@@ -80,20 +80,20 @@
     },
     {
       "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.",
+      "prompt": "Does the skill defer boot to the SessionStart hook rather than running it itself?",
+      "expected_output": "SKILL.md states boot (health check, core context, version banner, statusline) is owned by hook-session-start / plastic-statusline, not this skill.",
       "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" }
+        { "type": "convention", "check": "SKILL.md says boot is owned by the SessionStart hook and the skill does not run it", "observed": "'Boot is not this skill's job.' paragraph naming hook-session-start and plastic-statusline", "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.",
+      "prompt": "Does the skill avoid running doctor / setting the statusline itself?",
+      "expected_output": "SKILL.md does NOT instruct running doctor.rb --core or setting the statusline; it attributes those to the hooks.",
       "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" }
+        { "type": "convention", "check": "no in-skill boot step invokes doctor.rb --core or sets the statusline; both are attributed to hooks", "observed": "doctor --core and statusline mentioned only as hook-owned in the 'Boot is not this skill's job' note", "result": "pass" }
       ]
     },
     {
@@ -102,7 +102,7 @@
       "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" }
+        { "type": "convention", "check": "both dashboard invocations present and gated on project detection", "observed": "'dashboard.rb project <slug>' and 'dashboard.rb continue' in the 'Continue (present the dashboard)' section", "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)