@zalom/plastic 1.0.0-beta.33 → 1.0.0-beta.35

package/PLASTIC.md

@@ -213,12 +213,14 @@ run the main session on the best available thinking model (Fable, Opus, or whate
 them). This is advisory only: it changes no behavior and blocks nothing if ignored, and it
 concerns the human's main session, never a dispatched subagent.
 
-**`plastic-intent-discovery`.** The What-stage agent. It fires at intent activation, before the
-delivery lock is armed and Why begins: it reads the intent's `chain`/`sources` frontmatter,
-runs QMD-first discovery over completed predecessor work and related parked or future intents,
-and deposits findings to `resources/discovery--<slug>.md` in the intent directory ONLY. It
-never writes the intent file, `spec.md`, or any other lifecycle deliverable; the Why-stage
-`plastic-brainstorming` agent reads its deposit and enriches `## Context`.
+**`plastic-intent-discovery`.** The What-stage agent. It fires at intent activation, after the
+delivery lock is armed and before Why begins, running under that lock as the owner session (it
+does not acquire the lock itself and is not blocked by it): it reads the intent's
+`chain`/`sources` frontmatter, runs QMD-first discovery over completed predecessor work and
+related parked or future intents, and deposits findings to `resources/discovery--<slug>.md` in
+the intent directory ONLY. It never writes the intent file, `spec.md`, or any other lifecycle
+deliverable; the Why-stage `plastic-brainstorming` agent reads its deposit and enriches
+`## Context`.
 
 `savepoint.md` — a deterministic, append-only ledger of cycle-step milestones (one line per
 lifecycle boundary, newest at the bottom), written automatically by the gate hook. It is

package/agents/plastic-intent-discovery.md

@@ -7,13 +7,14 @@ description: |
   <example>Context: An intent is being moved from Future to Active.
   user: "Board this intent and gather what we already know"
   assistant: "I'll use the intent-discovery agent to run QMD discovery and deposit findings to resources/"
-  <commentary>What-stage discovery runs at activation, before the lock and Why.</commentary></example>
+  <commentary>What-stage discovery runs at activation, after the lock is armed, under it.</commentary></example>
 model: sonnet
 ---
 
 You are the Plastic Intent Discovery agent. You own the What stage: at intent
-activation, before the lock is armed and Why begins, you gather the context
-that already exists and deposit it for the Why stage to consume.
+activation, after the lock is armed and before Why begins, under the lock as
+the owner session, you gather the context that already exists and deposit it
+for the Why stage to consume.
 
 ## Responsibilities
 1. **Read the intent's links.** Load the activating intent file's `chain` and
@@ -32,6 +33,8 @@ that already exists and deposit it for the Why stage to consume.
 ## Constraints
 - Read-only with respect to the intent: your single output is
   `resources/discovery--<slug>.md`.
-- Never take the delivery lock; you run before it is armed.
+- You do not ACQUIRE the delivery lock; you run under the lock the
+  orchestrator armed (owner session, inherited session id) and are not
+  blocked by it.
 - End with a structured completion report per the spawn preamble's report
   contract.

package/bin/plastic.js

@@ -50,8 +50,12 @@ try {
   })
 } catch (err) {
   if (err.status) process.exit(err.status)
-  console.error('Error: Ruby is required to run Plastic.')
-  console.error('  macOS: Ruby is pre-installed')
-  console.error('  Linux: sudo apt install ruby / dnf install ruby')
+  // Ruby cannot run to print its own message when it is missing, so this
+  // mirrors scripts/lib/preflight.rb's FATAL block word for word.
+  console.error('Plastic needs Ruby 3.0.0 or newer to run its scripts (found not found).')
+  console.error('Install a pinned Ruby with mise:')
+  console.error('  curl https://mise.run | sh        # only if mise is not installed yet')
+  console.error('  mise use --global ruby@3.3')
+  console.error('Then re-run the Plastic installer.')
   process.exit(1)
 }

package/hooks/statusline

@@ -85,15 +85,57 @@ fi
 INDEX_DIR=$(dirname "$INDEX")
 
 # --- Current-session work-unit: the live bridge wins over savepoint recency ---
-# The statusline receives the real session_id on stdin; the session's bridge
-# (plastic-{session_id}.json) is the authoritative "what THIS session is driving".
-# This beats the shared, savepoint-recency heuristic so parallel sessions on one
-# store no longer overwrite each other's line. grep/sed only - no jq, no ruby.
+# The statusline receives the real session_id on stdin. A session can now own
+# SEVERAL per-intent bridges at once (intent 131, plastic-{session_id}--{id}.json),
+# one per concurrent delivery, so the statusline must pick which of them to show:
+# prefer a candidate whose worktree.code (or intent dir) prefixes REAL_CWD, else
+# the newest by mtime (ls -t is 3.2-safe); tolerate a legacy single-key
+# plastic-{session_id}.json when no per-intent file exists. This beats the shared,
+# savepoint-recency heuristic so parallel sessions on one store no longer
+# overwrite each other's line. grep/sed/ls only - no jq, no ruby.
 WORK=""
 SID=$(json_str "session_id")
 if [ -n "$SID" ]; then
-  BRIDGE="${PLASTIC_TMP:-/tmp}/plastic-${SID}.json"
-  if [ -f "$BRIDGE" ]; then
+  BR_TMP="${PLASTIC_TMP:-/tmp}"
+  BRIDGE=""
+  CANDIDATES=$(ls -1t "${BR_TMP}"/plastic-"${SID}"--*.json 2>/dev/null)
+  if [ -n "$CANDIDATES" ]; then
+    while IFS= read -r cand; do
+      [ -z "$cand" ] && continue
+      WT_BLOCK=$(sed -n '/"worktree"[[:space:]]*:[[:space:]]*{/,/}/p' "$cand" 2>/dev/null)
+      WC=$(printf '%s\n' "$WT_BLOCK" | grep -o '"code"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 \
+        | sed 's/.*"code"[[:space:]]*:[[:space:]]*"//;s/"$//')
+      IN_BLOCK=$(sed -n '/"intent"[[:space:]]*:[[:space:]]*{/,/}/p' "$cand" 2>/dev/null)
+      ISTORE=$(printf '%s\n' "$IN_BLOCK" | grep -o '"store"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 \
+        | sed 's/.*"store"[[:space:]]*:[[:space:]]*"//;s/"$//')
+      IDIR=$(printf '%s\n' "$IN_BLOCK" | grep -o '"dir"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 \
+        | sed 's/.*"dir"[[:space:]]*:[[:space:]]*"//;s/"$//')
+      MATCH=""
+      if [ -n "$WC" ] && [ -n "$REAL_CWD" ]; then
+        case "$REAL_CWD" in "$WC"|"$WC"/*) MATCH=1 ;; esac
+      fi
+      if [ -z "$MATCH" ] && [ -n "$ISTORE" ] && [ -n "$IDIR" ] && [ -n "$REAL_CWD" ]; then
+        IPATH="$ISTORE/$IDIR"
+        case "$REAL_CWD" in "$IPATH"|"$IPATH"/*) MATCH=1 ;; esac
+      fi
+      if [ -n "$MATCH" ]; then
+        BRIDGE="$cand"
+        break
+      fi
+    done <<BRIDGE_CAND_EOF
+$CANDIDATES
+BRIDGE_CAND_EOF
+    # No cwd/worktree signal on any candidate: fail open to the newest (ls -t
+    # already sorted CANDIDATES newest-first).
+    [ -z "$BRIDGE" ] && BRIDGE=$(printf '%s\n' "$CANDIDATES" | head -1)
+  else
+    # Legacy tolerance: no per-intent bridge for this session, but an old
+    # single-key file may still exist.
+    LEGACY="${BR_TMP}/plastic-${SID}.json"
+    [ -f "$LEGACY" ] && BRIDGE="$LEGACY"
+  fi
+
+  if [ -n "$BRIDGE" ] && [ -f "$BRIDGE" ]; then
     # Bridge JSON is pretty-printed (one field per line). Scope extraction to the
     # "intent" object so a sibling top-level "id"/"name" can never win (the intent
     # object holds only string fields, so the first "}" closes it). grep/sed only.

package/package.json

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

package/scripts/dashboard.rb

@@ -32,7 +32,11 @@ def today
   s && !s.empty? ? Date.parse(s) : Date.today
 end
 
-STALE_DAYS = 14
+# A generic "about a month" threshold, not tuned to any one store's item count.
+# Deliberately independent from plastic-continuing's separate stale_threshold_days
+# config: that one is a proactive boot-time triage nudge, this is a board annotation.
+# Unifying the two is a follow-up, not this intent.
+STALE_DAYS = 30
 
 # ---------------------------------------------------------------------------
 # Parsing — reuses the conventions in scripts/doctor.rb
@@ -105,6 +109,26 @@ def last_accessed_at(dir, created)
   ""
 end
 
+# True iff the savepoint ledger's last non-blank line shows real post-birth
+# activity, not just the one-line birth stamp every intent gets at creation
+# (scripts/new-intent's Bridge.append_savepoint call, stage "What"). Reads the
+# last line, extracts the stage token (second whitespace-separated field, same
+# ledger shape last_accessed_at already parses), and treats any stage other
+# than "What" as progress. Returns false when the file is missing/empty.
+def savepoint_shows_progress?(path)
+  return false unless File.exist?(path)
+  last_line = nil
+  File.readlines(path).reverse_each do |line|
+    stripped = line.strip
+    next if stripped.empty?
+    last_line = stripped
+    break
+  end
+  return false unless last_line
+  stage = last_line.split(/\s+/)[1]
+  !stage.nil? && stage != "What"
+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)
@@ -113,7 +137,6 @@ def parse_intent(store_info, dir_name, status_index)
   return nil unless fm && fm["id"]
 
   id = fm["id"].to_s
-  has = ->(f) { File.exist?(File.join(dir, f)) }
   # Sentinel-aware presence for lifecycle files (intent 60b): a scaffolded
   # placeholder spec/plan/checklist/outcome reads as absent, so a freshly
   # scaffolded intent reports What/Why and is never marked completed/advanced.
@@ -143,7 +166,7 @@ def parse_intent(store_info, dir_name, status_index)
     plan: real.("plan.md"),
     checklist: real.("checklist.md"),
     outcome: real.("outcome.md"),
-    savepoint: has.("savepoint.md"),
+    savepoint: savepoint_shows_progress?(File.join(dir, "savepoint.md")),
     checklist_partial: real.("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 "")),
@@ -163,6 +186,7 @@ end
 def load_all
   all = []
   done_ids = {}
+  completed_on_map = {}
   stores.each do |si|
     idx = {
       active: index_section_ids(si[:index], "## Active"),
@@ -176,11 +200,12 @@ def load_all
       rec[:completed_on] = comp[rec[:id]] || ""
       all << rec
       done_ids[[rec[:scope], rec[:id]]] = true if rec[:status] == "completed"
+      completed_on_map[[rec[:scope], rec[:id]]] = comp[rec[:id]] if comp[rec[:id]] && !comp[rec[:id]].empty?
     end
   end
   referenced = {}
   all.each { |r| r[:sources].each { |s| referenced[[r[:scope], s]] = true } }
-  [all, done_ids, referenced]
+  [all, done_ids, referenced, completed_on_map]
 end
 
 # ---------------------------------------------------------------------------
@@ -214,11 +239,14 @@ end
 
 # Effort -> :small | :big
 # Small when the work is bounded: a non-implementation type, an already-scoped intent
-# (plan/checklist exists), or a deep refinement branch. Otherwise big.
+# (plan/checklist exists), or a branch id. By Plastic's own Zettelkasten convention, a
+# branch id is a narrower refinement of its parent, so any branch (not only deep
+# sub-branches) defaults to smaller effort than an untouched root idea; root ids
+# (`root_intent?`) are unaffected since `folgezettel_depth` on a bare number is always 1.
 def effort_of(rec, type)
   return :small if %w[research exploration bugfix].include?(type)
   return :small if rec[:plan] || rec[:checklist]
-  return :small if folgezettel_depth(rec[:id]) >= 4
+  return :small if folgezettel_depth(rec[:id]) >= 2
   :big
 end
 
@@ -238,11 +266,12 @@ def value_of(rec, referenced = {})
   :low
 end
 
-def flags_of(rec, done_ids)
+def flags_of(rec, done_ids, completed_on_map = {})
   flags = []
   flags << "in-progress" if rec[:savepoint] || rec[:checklist_partial]
   if rec[:status] == "future" && !rec[:sources].empty? &&
-     rec[:sources].all? { |s| done_ids[[rec[:scope], s]] }
+     rec[:sources].all? { |s| done_ids[[rec[:scope], s]] } &&
+     genuine_wait?(rec, completed_on_map)
     flags << "unblocked"
   end
   age = stale_age(rec)
@@ -250,6 +279,22 @@ def flags_of(rec, done_ids)
   flags
 end
 
+# True iff at least one declared source's completion date is strictly later
+# than this intent's own `created` date — i.e. the intent actually waited on
+# something, rather than being born already-satisfied (the common case: a
+# branch's declared source is almost always finished before the branch exists,
+# since the child is created from the parent's own lifecycle).
+def genuine_wait?(rec, completed_on_map)
+  created_date = (Date.parse(rec[:created]) rescue nil)
+  return false unless created_date
+  rec[:sources].any? do |s|
+    source_date_str = completed_on_map[[rec[:scope], s]]
+    next false unless source_date_str
+    source_date = (Date.parse(source_date_str) rescue nil)
+    source_date && source_date > created_date
+  end
+end
+
 def stale_age(rec)
   return nil if rec[:created].nil? || rec[:created].empty?
   (today - Date.parse(rec[:created])).to_i
@@ -274,13 +319,13 @@ def disposition_of(type, quadrant)
   end
 end
 
-def classify(rec, done_ids, referenced = {})
+def classify(rec, done_ids, referenced = {}, completed_on_map = {})
   type = intent_type(rec)
   value = value_of(rec, referenced)
   effort = effort_of(rec, type)
   quadrant = QUADRANTS[[value, effort]]
   disposition = disposition_of(type, quadrant)
-  flags = flags_of(rec, done_ids)
+  flags = flags_of(rec, done_ids, completed_on_map)
   rec.merge(
     type: type, value: value, effort: effort, quadrant: quadrant,
     lifecycle: lifecycle_stage(rec), flags: flags, disposition: disposition,
@@ -329,6 +374,13 @@ end
 
 CELL_CAP = 6
 
+# Markdown-board caps (Task 5, D6/D7): the ASCII renderer already caps via CELL_CAP/
+# cap_cell, but the Markdown board's matrix_data quadrants and the project board's
+# active/future lists had no cap and no per-line truncation, so a large store printed
+# hundreds of full-length lines. These two constants fix that on the Markdown side only.
+MATRIX_DATA_CAP = 8
+INTENT_LINE_MAX_CHARS = 120
+
 def matrix(records, scope_tag: false)
   cells = { "quick_win" => [], "next_big" => [], "defer" => [], "triage" => [] }
   research = []
@@ -526,8 +578,23 @@ end
 
 def intent_line(rec, bullet)
   note = rec[:status] == "active" ? " (#{rec[:lifecycle].to_s.capitalize})" : ""
+  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]} #{rec[:intent]}#{note}".rstrip }
+    scope: rec[:scope], line: "#{bullet} #{rec[:id]} #{text}#{note}".rstrip }
+end
+
+# Cap a raw record list to MATRIX_DATA_CAP entries, then map to intent_line-shaped
+# hashes, appending a plain "+N more" line (no id, not a real record) when truncated.
+# Caps the record list first so the "+N more" entry never goes through intent_line.
+def cap_lines(list, bullet)
+  capped = list.first(MATRIX_DATA_CAP)
+  lines = capped.map { |r| intent_line(r, bullet) }
+  if list.size > MATRIX_DATA_CAP
+    lines << { id: "", intent: "", created: "", bullet: bullet, scope: "",
+               line: "#{bullet} +#{list.size - MATRIX_DATA_CAP} more" }
+  end
+  lines
 end
 
 def matrix_data(records)
@@ -539,8 +606,8 @@ def matrix_data(records)
   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, "🔬") }
+  cells.each { |q, list| out[q] = cap_lines(by_created_desc.call(list), QUADRANT_BULLET[q]) }
+  out["research"] = cap_lines(by_created_desc.call(research), "🔬")
   out
 end
 
@@ -606,12 +673,10 @@ def render_data_project(records, slug)
     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"]) } }
+    active: cap_lines(scoped.select { |r| r[:status] == "active" }
+                            .sort_by { |r| invert_ts(r[:last_accessed_at]) }, STATUS_GLYPH["active"]),
+    future: cap_lines(scoped.select { |r| r[:status] == "future" }
+                            .sort_by { |r| invert_ts(r[:created]) }, STATUS_GLYPH["future"]) }
 end
 
 # ---------------------------------------------------------------------------
@@ -645,8 +710,8 @@ def main(argv)
   mode = argv.shift || "continue"
   slug = argv.shift
 
-  raw, done_ids, referenced = load_all
-  records = raw.map { |r| classify(r, done_ids, referenced) }
+  raw, done_ids, referenced, completed_on_map = load_all
+  records = raw.map { |r| classify(r, done_ids, referenced, completed_on_map) }
 
   if data
     payload = mode == "project" ? render_data_project(records, slug) : render_data_global(records)

package/scripts/hook-continue

@@ -7,6 +7,7 @@
 
 require "json"
 require "open3"
+require_relative "lib/dashboard_banner"
 
 index_path, _store_root, _mode = ARGV
 exit 0 unless index_path && File.exist?(index_path)
@@ -28,4 +29,20 @@ payload = {
     "additionalContext" => context
   }
 }
+
+# Hook-owned systemMessage floor (intent 125, Task 6): a hard fallback summary
+# independent of the agent's reply, mirroring hook-session-start's BootBanner
+# pattern. Best-effort only — any failure here (subprocess, JSON, renderer)
+# degrades silently, omitting systemMessage; this hook must never crash
+# UserPromptSubmit over a summary line.
+begin
+  data_json, _data_err, data_status = Open3.capture3("ruby", dashboard, "continue", "--data")
+  if data_status.success?
+    banner = DashboardBanner.render(JSON.parse(data_json))
+    payload["systemMessage"] = banner if banner
+  end
+rescue StandardError
+  nil
+end
+
 puts JSON.generate(payload)

package/scripts/install.rb

@@ -14,6 +14,7 @@
 # so install.rb is the single file-syncer; the ledger action is contextual.
 
 require_relative "lib/installer_core"
+require_relative "lib/preflight"
 
 class Install < InstallerCore
   def cli(argv = ARGV)
@@ -22,6 +23,9 @@ class Install < InstallerCore
       return 0
     end
 
+    gate = preflight_gate
+    return gate unless gate.zero?
+
     force = argv.include?("--force")
     reinstall = argv.include?("--reinstall")
     ledger_action = flag_value(argv, "--ledger-action")
@@ -42,19 +46,19 @@ class Install < InstallerCore
       return 1
     end
 
-    run(selected: selected, force: force, reinstall: reinstall, ledger_action: ledger_action)
+    run(selected: selected, force: force, reinstall: reinstall, ledger_action: ledger_action, argv: argv)
     0
   end
 
   # Hermetic entrypoint (no prompting / no exit). Returns the per-agent results array.
-  def run(selected:, force: false, reinstall: false, ledger_action: nil)
+  def run(selected:, force: false, reinstall: false, ledger_action: nil, argv: ARGV, input: $stdin)
     fresh = !installed?
     mode = fresh ? :install : :update # :update here means "re-sync, skip bootstrap"
 
     distribute(mode)
     bootstrap if fresh
 
-    results = selected.map { |key| install_for_agent(key, force) }
+    results = selected.map { |key| install_for_agent(key, force, argv: argv, input: input, reinstall: reinstall) }
 
     action = ledger_action || (fresh ? "install" : "reinstall")
     ledger_append(version, action)
@@ -72,8 +76,37 @@ class Install < InstallerCore
     File.exist?(path) ? File.read(path).strip : nil
   end
 
+  # Injectable pre-flight gate: real probes as default args, printing to an
+  # injectable `out:` IO so this is hermetically testable via StringIO. Returns
+  # 1 (stop the install) when Ruby is missing/too-old, else 0.
+  def preflight_gate(ruby_version: RUBY_VERSION, node_version: node_probe, git_present: git_probe,
+                      mise_present: mise_probe, out: $stderr)
+    result = Preflight.check(ruby_version: ruby_version, node_version: node_version,
+                              git_present: git_present, mise_present: mise_present)
+    result[:messages].each { |message| out.puts(message) }
+    result[:fatal] ? 1 : 0
+  end
+
   private
 
+  def node_probe
+    `node --version`.strip
+  rescue StandardError
+    ""
+  end
+
+  def git_probe
+    !`command -v git`.strip.empty?
+  rescue StandardError
+    false
+  end
+
+  def mise_probe
+    !`command -v mise`.strip.empty?
+  rescue StandardError
+    false
+  end
+
   def flag_value(argv, name)
     i = argv.index(name)
     return nil unless i && argv[i + 1]
@@ -119,9 +152,12 @@ class Install < InstallerCore
         --alpha       Alpha channel
 
       Other options:
-        --reinstall   Re-sync core files for the installed version (repair). Store untouched.
-        --force       Overwrite existing files without prompting
-        -h, --help    Show this help
+        --reinstall          Re-sync core files for the installed version (repair). Store untouched.
+        --force              Overwrite existing files without prompting
+        --statusline VALUE   keep or plastic. If an existing statusline is found, this
+                             skips the interactive prompt. Interactive sessions ask by
+                             default; non-interactive sessions default to keep.
+        -h, --help           Show this help
 
       Notes:
         Install is one-shot. If Plastic is already installed, use `update` to upgrade or