@zalom/plastic 1.1.3 → 1.1.5

package/PLASTIC.md

@@ -10,6 +10,7 @@ See `PLASTIC-reference.md` for reference material: read it on demand, it is not
 
 A directory in the store containing `{ID}--{slug}.md` and optional supporting files.
 It represents a desire: something a human or agent wants to accomplish, explore, or understand.
+The unit of work in Plastic is always an intent, never a ticket.
 
 ```
 store/

package/README.md

@@ -44,7 +44,7 @@ Plastic makes that thinking legible, resumable, and useful later.
 
 **Plastic is built for an AI-native developer, technical founder, or
 independent builder who works across multiple sessions, has ideas before
-they have tickets, and feels the cost of losing reasoning between agents,
+they have intents, and feels the cost of losing reasoning between agents,
 contexts, and days.**
 
 ## What it solves?

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalom/plastic",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Intent-driven idea development system for AI coding agents",
   "type": "module",
   "bin": {

package/scripts/dashboard.rb

@@ -551,6 +551,19 @@ def within_24h?(rec)
   d && d >= (today - 1)
 end
 
+# Collapse whitespace to single spaces, strip, then escape Markdown table pipes so
+# free-text payload data is safe to drop verbatim into a table cell. Block-form gsub
+# avoids replacement-string backslash pitfalls.
+def cell(s)
+  s.to_s.gsub(/\s+/, " ").strip.gsub("|") { "\\|" }
+end
+
+# Truncate an intent title to the shared line budget, ellipsis when over.
+def truncate_intent(text)
+  t = text.to_s
+  t.length > INTENT_LINE_MAX_CHARS ? "#{t[0, INTENT_LINE_MAX_CHARS]}…" : t
+end
+
 def worked_row(rec, project_scope)
   glyph = STATUS_GLYPH[rec[:status]]
   proj = rec[:scope] == "global" ? "global" : rec[:scope].sub("project:", "")
@@ -559,6 +572,7 @@ def worked_row(rec, project_scope)
   {
     id: rec[:id], status: rec[:status], glyph: glyph,
     last_accessed_at: rec[:last_accessed_at],
+    what: cell(truncate_intent(rec[:intent])), state: status_word, scope: cell(proj),
     line: "#{glyph} #{prefix}#{status_word}: #{rec[:id]} #{rec[:intent]}".strip,
   }
 end
@@ -578,7 +592,8 @@ def intent_line(rec, bullet)
   text = rec[:intent].to_s
   text = "#{text[0, INTENT_LINE_MAX_CHARS]}…" if text.length > INTENT_LINE_MAX_CHARS
   { id: rec[:id], intent: rec[:intent], created: rec[:created], bullet: bullet,
-    scope: rec[:scope], line: "#{bullet} #{rec[:id]} #{text}#{note}".rstrip }
+    scope: rec[:scope], what: cell(text), stage: rec[:lifecycle].to_s.capitalize,
+    line: "#{bullet} #{rec[:id]} #{text}#{note}".rstrip }
 end
 
 # Cap a raw record list to NEXT_WORK_CAP entries, then map to intent_line-shaped
@@ -589,6 +604,7 @@ def cap_lines(list, bullet)
   lines = capped.map { |r| intent_line(r, bullet) }
   if list.size > NEXT_WORK_CAP
     lines << { id: "", intent: "", created: "", bullet: bullet, scope: "",
+               what: "+#{list.size - NEXT_WORK_CAP} more", stage: "",
                line: "#{bullet} +#{list.size - NEXT_WORK_CAP} more" }
   end
   lines
@@ -607,11 +623,13 @@ def next_work(records)
     text = "#{text[0, INTENT_LINE_MAX_CHARS]}…" if text.length > INTENT_LINE_MAX_CHARS
     { id: r[:id], intent: r[:intent], scope: r[:scope], lifecycle: r[:lifecycle],
       value: r[:value].to_s, disposition: r[:disposition], flags: r[:flags],
+      what: cell(text), flags_label: cell(Array(r[:flags]).join(", ")),
       line: "#{r[:id]} #{text}" }
   end
   if ranked.size > NEXT_WORK_CAP
     lines << { id: "", intent: "", scope: "", lifecycle: "", value: "", disposition: "",
-               flags: [], line: "+#{ranked.size - NEXT_WORK_CAP} more" }
+               flags: [], what: "+#{ranked.size - NEXT_WORK_CAP} more", flags_label: "",
+               line: "+#{ranked.size - NEXT_WORK_CAP} more" }
   end
   lines
 end

package/skills/dashboard/SKILL.md

@@ -34,9 +34,13 @@ 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`,
-`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`.
+`next_work`, `counts`, `projects`, `project_totals`. Project-board fields: `slug`, `store_health`,
+`description`, `recently_worked`, `next_work`, `counts`, `active`, `future`. Each list carries
+cell-ready fields for its table: `next_work` rows are
+`{id, intent, scope, lifecycle, value, disposition, flags, what, flags_label, line}`;
+`recently_worked` rows carry `{id, status, glyph, last_accessed_at, what, state, scope, line}`;
+`active`/`future` rows carry `{id, intent, created, bullet, scope, what, stage, line}`. The `what`,
+`scope`, and `flags_label` cell fields arrive pipe-escaped and whitespace-normalized.
 
 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
@@ -53,13 +57,22 @@ Templates live in this skill's `templates/` directory:
 
 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 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:
+- `{{<list>.rows}}` → the four intent lists (`recently_worked`, `next_work`, `active`, `future`)
+  render as **Markdown table rows**. The template hard-codes each table's header and separator;
+  this placeholder becomes one data row per list entry, joined with real newlines, in that table's
+  fixed column order (below). Drop each cell from the named payload field **verbatim**: cells
+  arrive pre-escaped and whitespace-normalized from the script (pipes escaped as `\|`), so never
+  re-escape, re-truncate, or reword them. Never emit `<br>`.
+  - `recently_worked` (global) → `| {id} | {what} | {state} | {scope} |`
+  - `recently_worked` (project) → `| {id} | {what} | {state} |`
+  - `next_work` → `| {id} | {what} | {value} | {disposition} | {flags_label} |`
+  - `active` → `| {id} | {what} | {stage} |`
+  - `future` → `| {id} | {what} |`
+  Overflow entry (empty `id`, `what` = `+N more`) → one row with `+N more` in the Id column and
+  every other cell blank. Empty list → one full-width row with `_(none)_` in the Id column and
+  every other cell blank, matching that table's column count (e.g. `| _(none)_ | | | | |` for
+  the 5-column next_work table, `| _(none)_ | |` for the 2-column future table).
+- `{{projects.lines}}` → the project rollup stays **prose**, one line per project (not a table):
   `- **{slug}**: {description}, active {active}, done {done}, future {future}, last accessed {last_accessed_at[0,10]}`.
 - Scalars (`{{date}}`, `{{slug}}`, `{{description}}`) → substitute verbatim.
 
@@ -126,7 +139,8 @@ intentional change means the skill is broken.
 
 ## Notes
 
-- 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>`.
+- The four intent lists (recently worked, active, future, next work) render as Markdown tables;
+  the narrative wrappers, counts, and the project rollup stay prose. No Value x Effort grid
+  returns. 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/evals/evals.json

@@ -17,6 +17,22 @@
           "result": "pass"
         }
       ]
+    },
+    {
+      "id": 2,
+      "scope": "behavior",
+      "set": "validation",
+      "prompt": "How do the four intent lists render on the Markdown boards?",
+      "expected_output": "recently_worked, next_work, active, and future render as Markdown tables (fixed columns: next_work Id|What|Value|Disposition|Flags; active Id|What|Stage; future Id|What; recently_worked Id|What|State, plus a Scope column on the global board). The narrative wrappers, counts, and the projects rollup stay prose; no Value x Effort grid. Cells arrive pre-escaped from the payload and are dropped verbatim.",
+      "files": ["skills/dashboard/templates/dashboard-global.md", "skills/dashboard/templates/dashboard-project.md", "skills/dashboard/SKILL.md"],
+      "assertions": [
+        {
+          "type": "convention",
+          "check": "the four intent lists render as Markdown tables with the fixed columns; wrappers and the projects rollup stay prose; no grid",
+          "observed": "templates hard-code table headers plus {{list.rows}} for recently_worked/next_work/active/future; SKILL.md Step 2 documents the fixed column order and verbatim pre-escaped cell fill; projects stays {{projects.lines}} prose",
+          "result": "pass"
+        }
+      ]
     }
   ]
 }

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

@@ -1,7 +1,10 @@
 # 🧩 Plastic · Global Board, {{date}}
 
 **Recently worked** (last 24h)
-{{recently_worked.lines}}
+
+| Id | What | State | Scope |
+| --- | --- | --- | --- |
+{{recently_worked.rows}}
 
 ## Where we are
 
@@ -11,6 +14,9 @@
 {{projects.lines}}
 
 ## Most-valuable next work
-{{next_work.lines}}
+
+| Id | What | Value | Disposition | Flags |
+| --- | --- | --- | --- | --- |
+{{next_work.rows}}
 
 **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

@@ -3,19 +3,29 @@
 {{description}}
 
 **Recently worked** (last active work, last 24h)
-{{recently_worked.lines}}
+
+| Id | What | State |
+| --- | --- | --- |
+{{recently_worked.rows}}
 
 ## Intents, active {{counts.active}}, done {{counts.done}}, future {{counts.future}}
 
 **Active**
-{{active.lines}}
+
+| Id | What | Stage |
+| --- | --- | --- |
+{{active.rows}}
 
 **Future**
-{{future.lines}}
+
+| Id | What |
+| --- | --- |
+{{future.rows}}
 
 ## Most-valuable next work
-{{next_work.lines}}
 
-**Legend** · ○ What ◔ Why ◑ How ◕ Exec ● Done
+| Id | What | Value | Disposition | Flags |
+| --- | --- | --- | --- | --- |
+{{next_work.rows}}
 
 **What would you like to work on next?** (type an **intent id**, or **global** to go back)

package/skills/project-continuing/SKILL.md

@@ -91,6 +91,11 @@ was built against the live INDEX.md-parsing `--data` path (147, the DB cutover,
 landed). Its rule-name citations (`classification.md`, cited by name, not logic) and the
 `dashboard.rb project <slug> --data` -> `dashboard-project.md` path still resolve.
 
+Intent 149a has landed on top of 149: the four intent lists (recently worked, active, future,
+next work) now render as Markdown tables. The prose demotion and the no-grid stance are unchanged,
+and the rule-name citations and the `dashboard.rb project <slug> --data` -> `dashboard-project.md`
+path still resolve.
+
 Intent 148 landed: roadmaps are the primary planning surface. When the tier has a mid-flight
 roadmap (`ruby ~/.plastic/scripts/roadmap-next --roadmaps-dir <tier>/roadmaps` reports a `state`
 other than `none`), the roadmap route (`plastic-roadmap-continuing`) is the live surface for

package/skills/project-continuing/evals/evals.json

@@ -72,10 +72,10 @@
     {
       "id": 8, "scope": "behavior", "set": "validation",
       "prompt": "Does the skill carry the intent-149 coordination note?",
-      "expected_output": "A 'Coordination' section records that intent 149 has landed (dashboard demoted to prose, no Value x Effort grid) and confirms the rule-name citations and the dashboard.rb project <slug> --data -> dashboard-project.md path still resolve.",
+      "expected_output": "A 'Coordination' section records that intent 149 has landed (dashboard demoted to prose, no Value x Effort grid) and intent 149a has landed (the four intent lists render as Markdown tables), and confirms the rule-name citations and the dashboard.rb project <slug> --data -> dashboard-project.md path still resolve.",
       "files": ["skills/project-continuing/SKILL.md"],
       "assertions": [
-        { "type": "convention", "check": "'149' present with the landed coordination note", "observed": "present: 'Intent 149 has landed' with confirmed rule-name citations and dashboard.rb path", "result": "pass" }
+        { "type": "convention", "check": "'149' present with the landed coordination note", "observed": "present: 'Intent 149 has landed' and 'Intent 149a has landed' (lists render as Markdown tables) with confirmed rule-name citations and dashboard.rb path", "result": "pass" }
       ]
     },
     {

package/skills/project-continuing/references/board-fill.md

@@ -7,11 +7,19 @@ would otherwise bloat the SKILL.md body.
 ## Fill rules (owned by plastic-dashboard, summarized here for convenience)
 
 - `{{a.b.count}}` -> the integer (e.g. `counts.active` is that count).
-- `{{...lines}}` -> join the list's `.line` strings with real newlines (one per line). These
-  are ordinary prose lines; never add a `-` prefix, never emit `<br>`. An empty list renders
-  `_(none)_`.
-- `next_work.lines` -> the most-valuable next work, already ranked and capped.
-- `active.lines` / `future.lines` (project board) -> one line per intent, already formatted.
+- `{{<list>.rows}}` -> the four intent lists (`recently_worked`, `next_work`, `active`, `future`)
+  render as Markdown table rows. The template hard-codes each table's header and separator; the
+  placeholder becomes one data row per entry, in that table's fixed column order, cells dropped
+  verbatim from the payload (cells arrive pipe-escaped and whitespace-normalized; do not re-escape
+  or re-truncate). Column order per table:
+  - `recently_worked` -> `| id | what | state | scope |` (global), `| id | what | state |` (project)
+  - `next_work` -> `| id | what | value | disposition | flags_label |`
+  - `active` -> `| id | what | stage |`; `future` -> `| id | what |`
+  Overflow entry (empty `id`, `what` = `+N more`) -> `+N more` in the Id column, other cells blank.
+  Empty list -> one full-width row with `_(none)_` in the Id column, other cells blank, matching
+  that table's column count (e.g. `| _(none)_ | | | | |` for the 5-column next_work table,
+  `| _(none)_ | |` for the 2-column future table). Never emit `<br>`.
+- `{{projects.lines}}` (global board) -> the project rollup stays prose, one line per project.
 - Scalars (`{{date}}`, `{{slug}}`, `{{description}}`) -> substitute verbatim.
 
 No re-sorting, no re-summarizing, no hand-written prose replacing a line the payload already

package/skills/roadmap/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: plastic-roadmap
-description: Use when the user wants to plan a delivery batch, order waves of intents, ship a batch of tickets in one go, track a named collection of intents toward a goal, or asks for a "roadmap". Creates and maintains a roadmap file, a delivery-side collection of intents (the counterpart to a release), separate from INDEX.md status tracking.
+description: Use when the user wants to plan a delivery batch, order waves of intents, ship a batch of intents in one go, track a named collection of intents toward a goal, or asks for a "roadmap". Creates and maintains a roadmap file, a delivery-side collection of intents (the counterpart to a release), separate from INDEX.md status tracking.
 user-invocable: true
 ---
 

package/skills/roadmap-continuing/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   Use when the user wants to continue or resume a roadmap, pick up a mid-flight delivery batch,
   asks "where is the roadmap", or wants to resume the wave that was shipping, including an
   indirect ask that never names a roadmap directly (for example "where did that batch of
-  tickets land"). This is the roadmap route of plastic-continuing: it finds the tier's
+  intents land"). This is the roadmap route of plastic-continuing: it finds the tier's
   mid-flight roadmap, presents its state, then asks how to proceed exactly once.
 user-invocable: true
 ---

package/skills/roadmap-continuing/evals/evals.json

@@ -26,7 +26,7 @@
     },
     {
       "id": 3, "scope": "triggering", "set": "validation",
-      "prompt": "where did that batch of tickets land",
+      "prompt": "where did that batch of intents land",
       "expected_output": "Activates plastic-roadmap-continuing (indirect trigger: a roadmap-resume request that never names 'roadmap' or 'continue').",
       "files": [],
       "assertions": [