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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalom/plastic",
-  "version": "1.0.0-alpha.21",
+  "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/skills/continuing/SKILL.md

@@ -54,11 +54,13 @@ state is loaded on top of it. For a full diagnosis, point the user at `/plastic-
 - 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`
+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`
 
-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/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)