@zalom/plastic 1.0.0-alpha.9 → 1.0.0-beta.10

package/hooks/gate-check

@@ -6,5 +6,7 @@ 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-gate-check" "$FILE_PATH"
+ruby "$SCRIPT_DIR/../scripts/hook-gate-check" "$FILE_PATH" "$SESSION_ID"

package/hooks/hooks.json

@@ -29,6 +29,38 @@
         ]
       }
     ],
+    "PreToolUse": [
+      {
+        "matcher": "Write|Edit|NotebookEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook\" code-gate",
+            "statusMessage": "Checking lifecycle gate..."
+          }
+        ]
+      },
+      {
+        "matcher": "Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook\" create-gate",
+            "statusMessage": "Checking create gate..."
+          }
+        ]
+      },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook\" bash-gate",
+            "statusMessage": "Checking lifecycle gate..."
+          }
+        ]
+      }
+    ],
     "PostToolUse": [
       {
         "matcher": "Write|Edit",
@@ -61,6 +93,26 @@
             "statusMessage": "Checking future intents..."
           }
         ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/auto-arm\"",
+            "statusMessage": "Checking auto mode..."
+          }
+        ]
+      },
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook\" qmd-search",
+            "statusMessage": "Searching QMD..."
+          }
+        ]
       }
     ]
   }

package/hooks/qmd-search

@@ -0,0 +1,8 @@
+#!/bin/bash
+# qmd-first search hook launcher (intent 66). No-op when there is no global store.
+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-qmd-search" "$HOME/.plastic"

package/hooks/statusline

@@ -1,56 +1,165 @@
 #!/bin/bash
-# plastic-hook-version: 2.0.0
-# StatusLine hook — chains user's original statusline, adds Plastic info
+# plastic-hook-version: 3.0.0
+# StatusLine hook - Plastic owns the full statusline (no chaining).
+# Renders: {model} - Plastic {version}[ -> {next}] - {path} - [{project}: {id} {title}]
+# Pure bash (macOS 3.2 compatible). No ruby, no jq. Reads stdin once; small file reads only.
 
 INPUT=$(cat)
 
-# --- Chain original statusline ---
-ORIGINAL_CONFIG="$HOME/.plastic/.cache/original-statusline.json"
-ORIGINAL_OUTPUT=""
-if [ -f "$ORIGINAL_CONFIG" ]; then
-  ORIGINAL_CMD=$(grep -o '"command":"[^"]*"' "$ORIGINAL_CONFIG" 2>/dev/null | head -1 | cut -d'"' -f4)
-  if [ -z "$ORIGINAL_CMD" ]; then
-    ORIGINAL_CMD=$(grep -o '"command": "[^"]*"' "$ORIGINAL_CONFIG" 2>/dev/null | head -1 | sed 's/.*"command": "//;s/".*//')
-  fi
-  if [ -n "$ORIGINAL_CMD" ] && [ -x "$ORIGINAL_CMD" ]; then
-    ORIGINAL_OUTPUT=$(echo "$INPUT" | "$ORIGINAL_CMD" 2>/dev/null)
+# --- Colors (ANSI-C quoting; bash 3.2 supports $'\033') ---
+C_MODEL=$'\033[38;2;90;140;220m'   # navy blue - model (lightened for legibility)
+C_VER=$'\033[37m'                  # white     - "Plastic {version}" and update arrow
+C_NEXT=$'\033[33m'                 # yellow    - next version
+C_PATH=$'\033[38;2;128;134;144m'   # gray      - path (matches dim UI text)
+C_BRACK=$'\033[33m'                # yellow    - work-unit brackets
+C_PROJ=$'\033[38;2;249;140;30m'    # orange    - project name
+C_ID=$'\033[38;2;45;212;191m'      # teal      - intent id (accent between orange + yellow)
+C_INTENT=$'\033[33m'               # yellow    - intent title
+C_SEP=$'\033[38;2;128;134;144m'    # gray      - separators
+RST=$'\033[0m'
+SEP="${C_SEP} "$'\302\267'" ${RST}"   # " . " middot, dim
+
+# --- Extract a flat JSON string field from stdin: json_str <key> ---
+json_str() {
+  printf '%s' "$INPUT" \
+    | grep -o "\"$1\"[[:space:]]*:[[:space:]]*\"[^\"]*\"" \
+    | head -1 \
+    | sed "s/.*\"$1\"[[:space:]]*:[[:space:]]*\"//;s/\"$//"
+}
+
+# --- Model (model.display_name) ---
+MODEL=$(json_str "display_name")
+
+# --- Path (workspace.current_dir, fallback top-level cwd) ---
+REAL_CWD=$(json_str "current_dir")
+[ -z "$REAL_CWD" ] && REAL_CWD=$(json_str "cwd")
+# Abbreviate $HOME -> ~
+CWD="$REAL_CWD"
+case "$CWD" in
+  "$HOME") CWD="~" ;;
+  "$HOME"/*) CWD="~${CWD#"$HOME"}" ;;
+esac
+
+# --- Plastic version ---
+VERSION=""
+[ -f "$HOME/.plastic/VERSION" ] && VERSION=$(tr -d ' \t\n' < "$HOME/.plastic/VERSION")
+
+# --- Update (next version when one is available) ---
+NEXT=""
+CACHE_FILE="$HOME/.plastic/.cache/update-check.json"
+if [ -f "$CACHE_FILE" ]; then
+  if grep -q '"updateAvailable"[[:space:]]*:[[:space:]]*true' "$CACHE_FILE" 2>/dev/null; then
+    LATEST=$(grep -o '"latest"[[:space:]]*:[[:space:]]*"[^"]*"' "$CACHE_FILE" 2>/dev/null \
+      | head -1 | sed 's/.*"latest"[[:space:]]*:[[:space:]]*"//;s/"$//')
+    if [ -n "$LATEST" ]; then
+      case "$LATEST" in
+        *-*) NEXT="${LATEST##*-}" ;;   # 1.0.0-beta.3 -> beta.3
+        *)   NEXT="$LATEST" ;;
+      esac
+    fi
   fi
 fi
 
-# --- Plastic status ---
-PLASTIC_PARTS=""
+# --- Scope resolution: cwd -> registered project store, else global ---
+# Match the longest registered project path that prefixes the real cwd.
+PROJECTS_YML="$HOME/.plastic/projects.yml"
+SLUG=""
+if [ -n "$REAL_CWD" ] && [ -f "$PROJECTS_YML" ]; then
+  SLUG=$(awk -v cwd="$REAL_CWD" '
+    /^  [A-Za-z0-9_.-]+:[[:space:]]*$/ { s=$1; sub(/:$/,"",s); next }
+    /^    path:/ {
+      p=$0; sub(/^[[:space:]]*path:[[:space:]]*/,"",p); gsub(/"/,"",p);
+      if (length(p)>0 && (cwd==p || index(cwd, p"/")==1) && length(p)>best) { best=length(p); win=s }
+    }
+    END { if (win!="") print win }
+  ' "$PROJECTS_YML")
+fi
 
-# Active intent from INDEX.md
-INDEX="$HOME/.plastic/INDEX.md"
-if [ -f "$INDEX" ]; then
-  ACTIVE=$(sed -n '/^## Active$/,/^## /{/^- \[/p;}' "$INDEX" | head -1)
-  if [ -n "$ACTIVE" ]; then
-    INTENT=$(echo "$ACTIVE" | sed 's/^- \[\([^]]*\)\].*/\1/')
-    PLASTIC_PARTS="plastic: ${INTENT}"
-  fi
+if [ -n "$SLUG" ]; then
+  INDEX="$HOME/.plastic/projects/$SLUG/INDEX.md"
+  PROJ_LABEL="$SLUG"
+else
+  INDEX="$HOME/.plastic/INDEX.md"
+  PROJ_LABEL="global"
 fi
+INDEX_DIR=$(dirname "$INDEX")
 
-# Update notification
-CACHE_FILE="$HOME/.plastic/.cache/update-check.json"
-if [ -f "$CACHE_FILE" ]; then
-  UPDATE_AVAILABLE=$(grep -o '"updateAvailable":true' "$CACHE_FILE" 2>/dev/null)
-  if [ -n "$UPDATE_AVAILABLE" ]; then
-    LATEST=$(grep -o '"latest":"[^"]*"' "$CACHE_FILE" 2>/dev/null | head -1 | cut -d'"' -f4)
-    CURRENT=$(grep -o '"current":"[^"]*"' "$CACHE_FILE" 2>/dev/null | head -1 | cut -d'"' -f4)
-    UPDATE_MSG="plastic update: $CURRENT -> $LATEST"
-    if [ -n "$PLASTIC_PARTS" ]; then
-      PLASTIC_PARTS="$PLASTIC_PARTS | $UPDATE_MSG"
-    else
-      PLASTIC_PARTS="$UPDATE_MSG"
+# --- 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.
+WORK=""
+SID=$(json_str "session_id")
+if [ -n "$SID" ]; then
+  BRIDGE="${PLASTIC_TMP:-/tmp}/plastic-${SID}.json"
+  if [ -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.
+    INTENT_BLOCK=$(sed -n '/"intent"[[:space:]]*:[[:space:]]*{/,/}/p' "$BRIDGE" 2>/dev/null)
+    B_ID=$(printf '%s\n' "$INTENT_BLOCK" | grep -o '"id"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 \
+      | sed 's/.*"id"[[:space:]]*:[[:space:]]*"//;s/"$//')
+    B_NAME=$(printf '%s\n' "$INTENT_BLOCK" | grep -o '"name"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 \
+      | sed 's/.*"name"[[:space:]]*:[[:space:]]*"//;s/"$//')
+    if [ -n "$B_ID" ] && [ -n "$B_NAME" ]; then
+      EMDASH=$'\342\200\224'
+      WORK="${B_ID} ${EMDASH} ${B_NAME}"
     fi
   fi
 fi
 
-# --- Combine output ---
-if [ -n "$ORIGINAL_OUTPUT" ] && [ -n "$PLASTIC_PARTS" ]; then
-  echo "$ORIGINAL_OUTPUT | $PLASTIC_PARTS"
-elif [ -n "$ORIGINAL_OUTPUT" ]; then
-  echo "$ORIGINAL_OUTPUT"
-elif [ -n "$PLASTIC_PARTS" ]; then
-  echo "$PLASTIC_PARTS"
+# --- Most-recently-accessed active intent (mirror dashboard: last savepoint ts) ---
+# Fallback only: runs when no session bridge resolved a work-unit above.
+if [ -z "$WORK" ] && [ -f "$INDEX" ]; then
+  BEST_TS=""
+  while IFS= read -r line; do
+    [ -z "$line" ] && continue
+    inside=${line#*[}; inside=${inside%%]*}             # "{id} - {title}"
+    dir=${line#*](store/}; dir=${dir%%/*}              # intent directory name
+    [ -z "$dir" ] && continue
+    sp="$INDEX_DIR/store/$dir/savepoint.md"
+    ts=""
+    if [ -f "$sp" ]; then
+      ts=$(grep -oE '[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z' "$sp" 2>/dev/null | tail -1)
+    fi
+    # ISO8601 sorts lexicographically; keep the newest. Empty ts sorts lowest.
+    if [ -z "$BEST_TS" ] || { [ -n "$ts" ] && [ "$ts" \> "$BEST_TS" ]; }; then
+      BEST_TS="$ts"
+      WORK="$inside"
+    fi
+  done <<EOF
+$(sed -n '/^## Active$/,/^## /{/^- \[/p;}' "$INDEX")
+EOF
+fi
+
+# --- Build the work-unit "[{project}: {id} {title}]" with title truncation ---
+WORK_SEG=""
+if [ -n "$WORK" ]; then
+  # Split "{id} - {title}" on the em-dash (U+2014).
+  EMDASH=$'\342\200\224'
+  id=${WORK%% $EMDASH *}
+  title=${WORK#* $EMDASH }
+  # Fallback if the em-dash form is absent: split on first space.
+  if [ "$id" = "$WORK" ]; then id=${WORK%% *}; title=${WORK#* }; fi
+  # Truncate long titles (~40 chars).
+  if [ ${#title} -gt 40 ]; then title="$(printf '%.40s' "$title")..."; fi
+  WORK_SEG="${C_BRACK}[${RST}${C_PROJ}${PROJ_LABEL}${RST}${C_INTENT}: ${RST}${C_ID}${id}${RST}${C_INTENT} ${title}${RST}${C_BRACK}]${RST}"
 fi
+
+# --- Assemble segments in order, joined by " . " ---
+PARTS=""
+add() { [ -z "$1" ] && return; if [ -z "$PARTS" ]; then PARTS="$1"; else PARTS="$PARTS$SEP$1"; fi; }
+
+# Order: stable values first (model, work-unit), then the volatile-length
+# values last (version, path) so the line does not visually jump as they change.
+[ -n "$MODEL" ] && add "${C_MODEL}${MODEL}${RST}"
+[ -n "$WORK_SEG" ] && add "$WORK_SEG"
+if [ -n "$VERSION" ]; then
+  vseg="${C_VER}Plastic ${VERSION}${RST}"
+  [ -n "$NEXT" ] && vseg="${vseg}${C_VER} "$'\342\206\222'" ${RST}${C_NEXT}${NEXT}${RST}"
+  add "$vseg"
+fi
+[ -n "$CWD" ] && add "${C_PATH}${CWD}${RST}"
+
+printf '%s\n' "$PARTS"

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@zalom/plastic",
-  "version": "1.0.0-alpha.9",
+  "version": "1.0.0-beta.10",
   "description": "Intent-driven idea development system for AI coding agents",
   "type": "module",
   "bin": {
-    "plastic": "bin/install.js"
+    "plastic": "bin/plastic.js"
   },
   "engines": {
     "node": ">=18.0.0"

package/scripts/agent-report

@@ -0,0 +1,142 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# agent-report - deterministic filesystem-derived completion report (intent 74).
+#
+# The auto-mode report contract is decision-shaped (the spawn preamble's
+# REPORT_CONTRACT plus the role prompts ask every dispatched agent to END with a
+# structured completion report). Because child-agent honor is best-effort across
+# harnesses (Tier B/C, docs/reference/harness-adapters.md), the contract is never a
+# hard block. This script is the always-a-report fallback: when a dispatched agent
+# returns no usable report, the enforcer runs it to synthesize one from the intent
+# directory, so the handoff account always exists.
+#
+# Like scripts/spawn-preamble, it is a PURE function of the intent dir: no network,
+# no randomness, no wall-clock reads. Two runs over the same on-disk state produce
+# byte-identical output.
+#
+# Usage:
+#   agent-report <intent_dir> [--role ROLE]
+#
+# Exit codes: 0 (report emitted), 2 (usage).
+
+require_relative "lib/bridge"
+
+def parse_args(argv)
+  role = nil
+  positional = []
+  i = 0
+  while i < argv.length
+    case argv[i]
+    when "--role"
+      role = argv[i + 1]
+      i += 2
+    else
+      positional << argv[i]
+      i += 1
+    end
+  end
+  [positional.first, role]
+end
+
+# Read the intent file frontmatter via the same path spawn-preamble uses, so the
+# id/intent we report match what the rest of Plastic sees. Never raises.
+def frontmatter_for(intent_dir)
+  ifile = Bridge.intent_file(intent_dir)
+  return {} unless File.exist?(ifile)
+
+  content = File.read(ifile)
+  return {} unless content.start_with?("---")
+
+  parts = content.split("---", 3)
+  return {} if parts.length < 3
+
+  require "yaml"
+  require "date"
+  require "time"
+  YAML.safe_load(parts[1], permitted_classes: [Date, Time]) || {}
+rescue StandardError
+  {}
+end
+
+# Current stage: prefer the last non-empty savepoint line (the ledger encodes the
+# furthest-reached milestone), else the file-derived stage. Same logic as
+# spawn-preamble's current_stage.
+STAGE_LABELS = {
+  "what" => "What", "why" => "Why", "how" => "How",
+  "exec" => "Exec", "done" => "Done"
+}.freeze
+
+def current_stage(intent_dir)
+  ledger = File.join(intent_dir, Bridge::SAVEPOINT_FILE)
+  if File.exist?(ledger)
+    last = File.read(ledger).each_line.map(&:strip).reject(&:empty?).last
+    return last if last
+  end
+  STAGE_LABELS.fetch(Bridge.derive_stage(intent_dir), Bridge.derive_stage(intent_dir))
+end
+
+# checklist.md checked/total: count GFM task-list items. Returns "n/a" when there
+# is no checklist (a checklist is only meaningful from How onward).
+def checklist_progress(intent_dir)
+  path = File.join(intent_dir, "checklist.md")
+  return "n/a" unless Bridge.stage_file_present?(path)
+
+  lines = File.readlines(path)
+  total = lines.count { |l| l =~ /^\s*- \[[ xX]\]/ }
+  checked = lines.count { |l| l =~ /^\s*- \[[xX]\]/ }
+  return "n/a" if total.zero?
+
+  "#{checked}/#{total}"
+end
+
+# The outcome line: first content line under outcome.md's "## Summary" (or the first
+# non-heading content line), else a placeholder. Pure read of the intent dir.
+def outcome_line(intent_dir)
+  path = File.join(intent_dir, "outcome.md")
+  return "(no outcome yet)" unless Bridge.stage_file_present?(path)
+
+  lines = File.readlines(path).map(&:rstrip)
+  start = lines.index { |l| l.strip.downcase == "## summary" }
+  scan = start ? lines[(start + 1)..] : lines
+  (scan || []).each do |l|
+    s = l.strip
+    next if s.empty? || s.start_with?("#") || s.start_with?("<!--")
+    return s
+  end
+  "(no outcome yet)"
+end
+
+intent_dir_arg, role = parse_args(ARGV)
+
+if intent_dir_arg.nil? || intent_dir_arg.empty?
+  warn "usage: agent-report <intent_dir> [--role ROLE]"
+  exit 2
+end
+
+intent_dir = File.expand_path(intent_dir_arg)
+
+fm = frontmatter_for(intent_dir)
+id = fm["id"].to_s.strip
+intent_name = fm["intent"].to_s.strip
+id = "(unknown)" if id.empty?
+intent_name = "(unknown)" if intent_name.empty?
+
+stage = current_stage(intent_dir)
+role_label = (role && !role.empty?) ? role : stage
+artifacts = Bridge.has_files(intent_dir)
+artifacts_str = artifacts.empty? ? "(none)" : artifacts.join(", ")
+
+lines = []
+lines << "=== Plastic agent report (synthesized) ==="
+lines << "Intent: #{id} - #{intent_name}"
+lines << "Stage: #{stage}"
+lines << "Role: #{role_label}"
+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 << "=== end report ==="
+
+puts lines.join("\n")