@zalom/plastic 1.0.0-beta.8 → 1.0.0

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/code-gate

@@ -1,6 +1,15 @@
 #!/bin/bash
 INPUT=$(cat)
-FILE_PATH=$(echo "$INPUT" | ruby -rjson -e 'data = JSON.parse(STDIN.read); puts data.dig("tool_params", "file_path") || data.dig("tool_input", "file_path") || ""' 2>/dev/null)
+FILE_PATH=$(echo "$INPUT" | ruby -rjson -e '
+  data = JSON.parse(STDIN.read)
+  ti = data["tool_input"] || data["tool_params"] || {}
+  path = ti["file_path"] || ti["notebook_path"] || ti["relative_path"] || ""
+  if !path.empty? && !path.start_with?("/")
+    root = ti["project_root"] || data["cwd"] || ""
+    path = File.join(root, path) unless root.empty?
+  end
+  puts path
+' 2>/dev/null)
 
 if [ -z "$FILE_PATH" ]; then
   exit 0

package/hooks/hooks.json

@@ -19,7 +19,7 @@
     ],
     "PreCompact": [
       {
-        "matcher": "manual|auto",
+        "matcher": "",
         "hooks": [
           {
             "type": "command",
@@ -31,17 +31,32 @@
     ],
     "PreToolUse": [
       {
-        "matcher": "Write|Edit|NotebookEdit",
+        "matcher": "Write|Edit|NotebookEdit|mcp__serena__replace_content|mcp__serena__replace_symbol_body|mcp__serena__insert_after_symbol|mcp__serena__insert_before_symbol|mcp__serena__safe_delete_symbol|mcp__serena__rename_symbol",
         "hooks": [
           {
             "type": "command",
             "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook\" code-gate",
             "statusMessage": "Checking lifecycle gate..."
+          },
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook\" lock-gate",
+            "statusMessage": "Checking lock gate..."
           }
         ]
       },
       {
-        "matcher": "Write",
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook\" savepoint-pre",
+            "statusMessage": "Recording stage start..."
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|mcp__serena__replace_content|mcp__serena__replace_symbol_body|mcp__serena__insert_after_symbol|mcp__serena__insert_before_symbol|mcp__serena__safe_delete_symbol|mcp__serena__rename_symbol",
         "hooks": [
           {
             "type": "command",
@@ -59,6 +74,16 @@
             "statusMessage": "Checking lifecycle gate..."
           }
         ]
+      },
+      {
+        "matcher": "Bash|Read|Grep|Glob",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook\" retrieval-gate",
+            "statusMessage": "Checking retrieval gate..."
+          }
+        ]
       }
     ],
     "PostToolUse": [

package/hooks/lock-gate

@@ -0,0 +1,21 @@
+#!/bin/bash
+INPUT=$(cat)
+FILE_PATH=$(echo "$INPUT" | ruby -rjson -e '
+  data = JSON.parse(STDIN.read)
+  ti = data["tool_input"] || data["tool_params"] || {}
+  path = ti["file_path"] || ti["notebook_path"] || ti["relative_path"] || ""
+  if !path.empty? && !path.start_with?("/")
+    root = ti["project_root"] || data["cwd"] || ""
+    path = File.join(root, path) unless root.empty?
+  end
+  puts path
+' 2>/dev/null)
+
+if [ -z "$FILE_PATH" ]; then
+  exit 0
+fi
+
+SESSION_ID=$(echo "$INPUT" | ruby -rjson -e 'data = JSON.parse(STDIN.read); puts data.dig("session_id") || ""' 2>/dev/null)
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+ruby "$SCRIPT_DIR/../scripts/hook-lock-gate" "$FILE_PATH" "$SESSION_ID"

package/hooks/retrieval-gate

@@ -0,0 +1,10 @@
+#!/bin/bash
+# Retrieval-gate hook launcher (intent 84, Lever 2). No-op when there is no
+# global store. Passes the PreToolUse JSON through on stdin (exec inherits it)
+# and the plastic_home as ARGV[0], mirroring the qmd-search launcher.
+GLOBAL_INDEX="$HOME/.plastic/INDEX.md"
+if [ ! -f "$GLOBAL_INDEX" ]; then
+  exit 0
+fi
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+exec ruby "$SCRIPT_DIR/../scripts/hook-retrieval-gate" "$HOME/.plastic"

package/hooks/savepoint-pre

@@ -0,0 +1,10 @@
+#!/bin/bash
+INPUT=$(cat)
+FILE_PATH=$(echo "$INPUT" | ruby -rjson -e 'data = JSON.parse(STDIN.read); puts data.dig("tool_params", "file_path") || data.dig("tool_input", "file_path") || ""' 2>/dev/null)
+
+if [ -z "$FILE_PATH" ]; then
+  exit 0
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+ruby "$SCRIPT_DIR/../scripts/hook-savepoint-pre" "$FILE_PATH"

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.8",
+  "version": "1.0.0",
   "description": "Intent-driven idea development system for AI coding agents",
   "type": "module",
   "bin": {
@@ -38,6 +38,7 @@
     "agents/",
     "templates/",
     "PLASTIC.md",
+    "PLASTIC-reference.md",
     "deprecations.yml"
   ]
 }

package/scripts/agent-report

@@ -108,6 +108,26 @@ def outcome_line(intent_dir)
   "(no outcome yet)"
 end
 
+# The insights line: the LAST line of the intent file's `## Insights` section
+# (the newest nugget, since entries are append-only newest-at-bottom), else
+# `(none)`. Pure read of the intent dir, no clock.
+def insights_line(intent_dir)
+  ifile = Bridge.intent_file(intent_dir)
+  return "(none)" unless File.exist?(ifile)
+
+  lines = File.read(ifile).split("\n", -1)
+  idx = lines.index { |l| l.strip == "## Insights" }
+  return "(none)" if idx.nil?
+
+  last = nil
+  (idx + 1).upto(lines.length - 1) do |i|
+    break if lines[i].start_with?("## ")
+
+    last = lines[i] unless lines[i].strip.empty?
+  end
+  last || "(none)"
+end
+
 intent_dir_arg, role = parse_args(ARGV)
 
 if intent_dir_arg.nil? || intent_dir_arg.empty?
@@ -137,6 +157,7 @@ lines << "Status: synthesized (filesystem-derived; no agent-authored report)"
 lines << "Artifacts present: #{artifacts_str}"
 lines << "Checklist: #{checklist_progress(intent_dir)}"
 lines << "Outcome: #{outcome_line(intent_dir)}"
+lines << "Insights: #{insights_line(intent_dir)}"
 lines << "=== end report ==="
 
 puts lines.join("\n")

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
 
 # ---------------------------------------------------------------------------
@@ -639,18 +704,28 @@ end
 # CLI
 # ---------------------------------------------------------------------------
 
+# JSON.pretty_generate renders empty arrays/objects as multi-line ("[\n\n  ]") on
+# some json gem versions and single-line ("[]") on others, so the same payload
+# serializes differently across environments. Collapse both to the single-line
+# form so dashboard JSON output is byte-identical everywhere. The \n requirement
+# in each pattern is what makes this safe: a raw newline is illegal inside a JSON
+# string, so neither pattern can ever match inside string content.
+def canonical_pretty_json(payload)
+  JSON.pretty_generate(payload).gsub(/\[\s*\n\s*\]/, "[]").gsub(/\{\s*\n\s*\}/, "{}")
+end
+
 def main(argv)
   json = argv.delete("--json")
   data = argv.delete("--data")
   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)
-    puts JSON.pretty_generate(payload)
+    puts canonical_pretty_json(payload)
     return 0
   end
 
@@ -664,7 +739,7 @@ def main(argv)
     # per-scope boards (keeping the all-scopes auto-mode contract stable).
     payload[:store_health] = store_health(slug) if mode == "project"
     payload[:store_health] = store_health(:global) if mode == "continue"
-    puts JSON.pretty_generate(payload)
+    puts canonical_pretty_json(payload)
     return 0
   end