@zalom/plastic 1.1.0 → 1.1.2

package/scripts/roadmap-savepoint

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

package/scripts/skill-lint

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# skill-lint: deterministic CLI over SkillLint (intent 85b).
+#
+# Runs the five structural skill checks (body-budget, frontmatter-validity,
+# bare-pointer, orphan-files, references-depth) over a directory of Agent
+# Skills and reports every violation. Mirrors `scripts/validate-intent`'s
+# CLI-over-lib shape and exit-code contract.
+#
+# Usage:
+#   skill-lint [--skills-dir <path>]
+#
+# Exit codes: 0 (clean), 1 (violations found; reported on stderr), 2 (usage).
+# --skills-dir defaults to the repo skills/ directory next to this script.
+
+require_relative "lib/skill_lint"
+
+def resolve_skills_dir(args)
+  if (i = args.index("--skills-dir"))
+    args[i + 1]
+  else
+    File.expand_path("../skills", __dir__)
+  end
+end
+
+if ARGV.any? { |a| a.start_with?("--") && a != "--skills-dir" }
+  warn "usage: skill-lint [--skills-dir <path>]"
+  exit 2
+end
+
+if ARGV.include?("--skills-dir") && ARGV[ARGV.index("--skills-dir") + 1].nil?
+  warn "usage: skill-lint [--skills-dir <path>]"
+  exit 2
+end
+
+dir = File.expand_path(resolve_skills_dir(ARGV))
+result = SkillLint.new(skills_dir: dir).run
+
+if result.ok?
+  puts "OK: #{dir}"
+  exit 0
+end
+
+warn "VIOLATIONS: #{dir}"
+result.violations.each do |v|
+  warn "#{v[:check]} #{v[:skill]} #{v[:file]}:#{v[:line].nil? ? "-" : v[:line]} #{v[:message]}"
+end
+exit 1

package/skills/auto/SKILL.md

@@ -15,7 +15,9 @@ Announce: "Taking over intent [ID] - [name] for autonomous delivery."
 orchestrating main session on the best available thinking model (Fable, Opus, or whatever
 supersedes them) for the sharpest gating and synthesis. This is advice only: it changes no
 behavior and blocks nothing if ignored. It concerns the human's MAIN session; dispatched
-subagents keep their pinned tier and never resolve to Fable.
+subagents keep their pinned tier and never resolve to Fable, unless an explicit
+`agents.models.<name>` config override names Fable for that role, in which case the override
+is honored as written.
 
 ## Precondition
 
@@ -24,8 +26,22 @@ An active intent MUST exist in INDEX.md. If none exists, refuse: "No active inte
 If multiple active intents exist, ask the user which one to deliver (this is the only question auto asks).
 
 **Picking work when no intent is specified.** If the user says "auto" without naming an
-intent and none is active, consult the dashboard's machine-readable queue to choose the
-next dispatchable intent:
+intent and none is active, consult the roadmap first (the primary planning surface), then
+fall back to the dashboard queue. Read the tier's mid-flight roadmap:
+
+```bash
+ruby ~/.plastic/scripts/roadmap-next --roadmaps-dir <tier>/roadmaps
+```
+
+Branch on `state`:
+- `dispatchable`: work its `dispatchable_queue` in `rank` order (the head is the next batch
+  entry). These are the current batch's `queued` intents, parallel-safe within the wave.
+- `in_flight`: the frontier batch is still delivering. Report it and wait. Do NOT dispatch a
+  later batch and do NOT fall through to the dashboard, the roadmap is live.
+- `none` or `exhausted`: no roadmap, or nothing left to dispatch. Fall back to the dashboard
+  queue below. (The global store has no roadmap, so it always reports `none` and falls back.)
+
+Dashboard fallback:
 
 ```bash
 ruby ~/.plastic/scripts/dashboard.rb all --json
@@ -54,8 +70,10 @@ and artifact depth to that size. Extended walkthrough: `references/tiers.md`.
    every tier and in both modes. A three-line spec.md is still a spec.md, in the same
    place, under the same gate.
 3. **Per-tier topology.** S/M: one thinker agent, one boot, two stations, sonnet
-   executor, `actions/` skipped; S may also skip the QMD discovery deposit when chain and
-   sources are both empty. L: today's full team (`## Team Spin-Up` below).
+   executor; the thinker writes at least one real action file (one consolidated
+   `actions/ACTION_1.md`), never an empty `actions/`. S may also skip the QMD discovery
+   deposit when chain and sources are both empty. L: today's full team (`## Team Spin-Up`
+   below), one `actions/ACTION_N.md` per task.
 4. **Never-cut list**, any tier or mode: the independent reviewer (separate agent, fresh
    context, never the maker), `outcome.md` as truth of delivery, the delivery lock,
    worktree isolation, intent creation via skill, INDEX as status truth, the QMD reindex
@@ -108,7 +126,9 @@ Dispatch rule: sequential, one specialist per stage on one branch (the deliverab
 
 Spawn preamble (live-state injection): before dispatching any specialist, run `scripts/spawn-preamble <intent_dir> --role <role>` and PREPEND its output to that specialist's prompt. The preamble is a deterministic, filesystem-only snapshot of the active intent (id, intent line, current stage, and the provisioned code worktree path when one exists on disk) plus the honoring instruction, so every spawned agent boots with accurate live state instead of guessing. This is the authoritative L2 mechanism for harnesses whose sub-agents do not inherit a top-level session event (see `docs/reference/harness-adapters.md`).
 
-Dispatch-time model contract (belt-and-braces): alongside the preamble, resolve each specialist's model through the config chain (`read-config agents.models.<basename> --project <repo>`: project override, then global, then the shipped tier default) and pass it explicitly at dispatch. Never rely on the dispatched role's frontmatter alone; a resolved subagent model is never Fable.
+Dispatch-time model contract (belt-and-braces): alongside the preamble, resolve each specialist's model through the config chain (`read-config agents.models.<basename> --project <repo>`: project override, then global, then the shipped tier default) and pass it explicitly at dispatch. Never rely on the dispatched role's frontmatter alone; a resolved subagent model is never Fable,
+unless an explicit `agents.models.<name>` config override names Fable for that role, in which
+case the override is honored as written.
 
 Completion report (require-then-synthesize): every dispatched specialist MUST end with a structured completion report as its final message. The preamble's `REPORT_CONTRACT` injects this and the role prompts carry the per-role format (see `references/agent-report-contract.md`). Because child-agent honor is best-effort across harnesses, this is decision-shaping, not a hard block. When a specialist returns no usable report (it went idle, emitted only a bare ping, or its message was lost to a mid-run interjection), run `scripts/agent-report <intent_dir> --role <role>` to synthesize a deterministic filesystem-derived report so the handoff account always exists. Use the agent-authored report when present, the synthesized one otherwise.
 
@@ -185,14 +205,15 @@ Then proceed to How.
 
 ## How Phase
 
-This is the L-tier shape (see `## Tiers` above); S/M skip step 3 and fold the checklist
-rationale into plan.md inline. The `actions/` directory itself is scaffolded empty at
-intent birth and persists at every tier; only writing `ACTION_N.md` files into it is L
-only (S/M leave the directory empty).
+Every tier runs all four steps below (see `## Tiers` above). The `actions/` directory is
+scaffolded (with a `.gitkeep`) at intent birth; the planner then writes at least one REAL
+`ACTION_N.md` into it at every tier. The tier only changes step 3's granularity: S/M write
+one consolidated `actions/ACTION_1.md`, L writes one `actions/ACTION_N.md` per task. A
+`.gitkeep`-only or empty `actions/` fails the How gate.
 
 1. If `superpowers:writing-plans` is available as a skill, delegate plan creation to it. Tell it the plan saves to the active intent's directory (not `docs/superpowers/plans/`).
 2. Otherwise, write `plan.md` directly - implementation plan with numbered tasks
-3. Write `ACTION_N.md` files into the existing `actions/` directory (one per task, self-contained) - L only
+3. Write at least one real `ACTION_N.md` into the existing `actions/` directory, self-contained (S/M: one consolidated `ACTION_1.md`; L: one per task)
 4. Write `checklist.md` - execution registry with checkboxes covering all actions
 5. Notify user (How briefing): brief per `references/human-report-contract.md`
    (State: the plan shape, task count and what it builds; Risk: the riskiest task or

package/skills/auto/references/tiers.md

@@ -30,9 +30,10 @@ the savepoint ledger.
 One thinker agent boots ONCE and stays in a single context for two stations:
 
 1. Station 1 — writes `spec.md` (collapsed sections allowed, one line each is valid).
-2. Station 2 — writes `plan.md` + `checklist.md` in the SAME context (no reboot). plan.md
-   carries the checklist rationale inline instead of separate `actions/ACTION_N.md` files.
-   `actions/` is not created for S/M.
+2. Station 2 — writes `plan.md` + `checklist.md` + at least one real action file in the
+   SAME context (no reboot). At S/M the thinker consolidates the whole delivery into one
+   `actions/ACTION_1.md` (rather than one file per task); `actions/` is populated at every
+   tier, and a `.gitkeep`-only or empty `actions/` fails the How gate.
 
 Then a sonnet executor (a fresh dispatch, this is the one topology split that always
 happens) implements from plan.md + checklist.md, checks off items, appends `## Insights`,

package/skills/continuing/SKILL.md

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

package/skills/continuing/evals/evals.json

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

package/skills/dashboard/SKILL.md

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

package/skills/dashboard/references/classification.md

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

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

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

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

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

package/skills/doctor/SKILL.md

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

package/skills/install/SKILL.md

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