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

package/scripts/hook-auto-arm

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Usage: hook-auto-arm <message>
+# UserPromptSubmit arming (intent 27). Two jobs, both additive context — never blocks:
+#   1. Detect auto-trigger phrases -> steer the agent to invoke plastic-auto.
+#   2. If auto mode is armed and the active intent hasn't reached How -> remind the agent
+#      that project-code edits are gate-blocked until plan.md + checklist.md exist.
+# Outputs UserPromptSubmit hookSpecificOutput JSON, or exits silently.
+
+require "json"
+require_relative "lib/bridge"
+
+message = (ARGV[0] || "").downcase
+parts = []
+
+# --- 1. Auto-trigger steering ---
+AUTO_TRIGGERS = ["take it from here", "deliver this", "/plastic-auto", "auto mode"].freeze
+# bare "auto" only as a standalone word to avoid matching "automatic", "automation", etc.
+triggered = AUTO_TRIGGERS.any? { |p| message.include?(p) } || message.match?(/\bauto\b/)
+if triggered
+  parts << "Auto-mode request detected. Invoke the plastic-auto skill to deliver the " \
+           "active intent autonomously — it arms the lifecycle gate so project code " \
+           "cannot be edited before plan.md + checklist.md exist."
+end
+
+# --- 2. Standing gate reminder when armed and pre-How ---
+bridge_data = Bridge.discover_bridge(session: ENV["CLAUDE_SESSION_ID"], cwd: Dir.pwd)
+if bridge_data && bridge_data.dig("build", "auto") == true
+  intent = bridge_data["intent"] || {}
+  store = intent["store"]; dir = intent["dir"]
+  if store && dir
+    intent_dir = File.expand_path("#{store}/#{dir}")
+    reached_how = File.exist?("#{intent_dir}/plan.md") && File.exist?("#{intent_dir}/checklist.md")
+    unless reached_how
+      parts << "Auto mode armed on intent #{intent["id"]} — produce spec -> plan -> " \
+               "checklist before editing project code. Code edits are gate-blocked until then."
+    end
+  end
+end
+
+exit 0 if parts.empty?
+
+payload = {
+  "hookSpecificOutput" => {
+    "hookEventName" => "UserPromptSubmit",
+    "additionalContext" => parts.join("\n")
+  }
+}
+puts JSON.generate(payload)

package/scripts/hook-bash-gate

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# PreToolUse gate for Bash (intent 27a): close the Bash-edit bypass. When auto
+# mode is armed and the active intent has not reached How (plan.md + checklist.md),
+# block Bash commands that WRITE project code outside the store.
+#
+# Reads the Claude Code PreToolUse payload as JSON on STDIN:
+#   { "tool_input": { "command": "..." }, "cwd": "..." }
+# Empty / unparseable / no command => exit 0 (allow). Conservatism is the prime
+# directive: when a command's write intent is ambiguous, ALLOW.
+#
+# Exit 0 = allow. Exit 2 = block (reason on stderr, shown to the agent).
+
+require "json"
+require_relative "lib/bridge"
+
+raw = $stdin.read rescue nil
+exit 0 if raw.nil? || raw.strip.empty?
+
+payload = JSON.parse(raw) rescue nil
+exit 0 unless payload.is_a?(Hash)
+
+command = payload.dig("tool_input", "command") || payload.dig("tool_params", "command")
+exit 0 if command.nil? || command.to_s.strip.empty?
+
+cwd = payload["cwd"]
+cwd = Dir.pwd if cwd.nil? || cwd.to_s.empty?
+
+# --- Load bridge (shared resolution; stdin session_id -> env -> /tmp scan) ---
+session = payload["session_id"]
+session = ENV["CLAUDE_SESSION_ID"] if session.nil? || session.to_s.empty?
+bridge_data = Bridge.discover_bridge(session: session, cwd: cwd)
+exit 0 unless bridge_data
+
+reason = Bridge.bash_gate_decision(bridge_data, command, cwd: cwd)
+exit 0 unless reason
+
+$stderr.puts "PLASTIC GATE — #{reason}"
+exit 2

package/scripts/hook-code-gate

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Usage: hook-code-gate <file_path>
+# PreToolUse gate (intent 27): when auto mode is armed and the active intent has not
+# reached How (plan.md + checklist.md), block edits to project code outside the store.
+#
+# Exit 0 = allow. Exit 2 = block (reason on stderr, shown to the agent).
+# No bridge / auto not armed / How reached / path under ~/.plastic or the intent dir = allow.
+
+require_relative "lib/bridge"
+
+file_path = ARGV[0]
+exit 0 unless file_path && !file_path.empty?
+
+session = (ARGV[1] unless ARGV[1].to_s.empty?) || ENV["CLAUDE_SESSION_ID"]
+
+# --- Load bridge (shared resolution; stdin session_id -> env -> /tmp scan) ---
+bridge_data = Bridge.discover_bridge(session: session, cwd: Dir.pwd)
+exit 0 unless bridge_data
+
+reason = Bridge.code_gate_decision(bridge_data, file_path)
+exit 0 unless reason
+
+$stderr.puts "PLASTIC GATE — #{reason}"
+exit 2

package/scripts/hook-continue

@@ -1,130 +1,31 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
 # Usage: hook-continue <index_path> <store_root> <mode>
-# Outputs hook JSON for the continue hook. Exits silently if nothing to show.
+# Renders the dashboard `continue` cockpit as UserPromptSubmit additionalContext.
+# Exits silently (no output) if the dashboard produces nothing — the bash caller
+# then falls back to a minimal notice.
 
 require "json"
-require "date"
-require "yaml"
+require "open3"
 
-index_path, store_root, mode = ARGV
-exit 0 unless index_path && store_root && mode
+index_path, _store_root, _mode = ARGV
+exit 0 unless index_path && File.exist?(index_path)
 
-# --- Parse INDEX.md ---
+dashboard = File.expand_path("dashboard.rb", __dir__)
+exit 0 unless File.exist?(dashboard)
 
-lines = File.readlines(index_path)
-active = []
-future = []
-section = nil
+cockpit, _err, status = Open3.capture3("ruby", dashboard, "continue")
+exit 0 unless status.success? && !cockpit.strip.empty?
 
-lines.each do |line|
-  if line.start_with?("## Active")
-    section = :active
-    next
-  elsif line.start_with?("## Future")
-    section = :future
-    next
-  elsif line.start_with?("## ")
-    section = nil
-    next
-  end
-
-  next unless section && line.strip.start_with?("- [")
-
-  if section == :active
-    active << line.strip
-  elsif section == :future
-    future << line.strip
-  end
-end
-
-# --- Detect stale future intents ---
-
-stale = []
-stale_days = 3
-config_path = "#{store_root}/config.yml"
-if File.exist?(config_path)
-  config = YAML.safe_load(File.read(config_path)) rescue {}
-  stale_days = config["stale_threshold_days"] || 3
-end
-
-future.each do |f|
-  if f =~ /store\/([\w-]+)\//
-    dir_name = $1
-    intent_file = "#{store_root}/store/#{dir_name}/#{dir_name}.md"
-    next unless File.exist?(intent_file)
-
-    content = File.read(intent_file)
-    if content =~ /^created:\s*['"]?(\d{4}-\d{2}-\d{2})/
-      age = (Date.today - Date.parse($1)).to_i
-      if age >= stale_days
-        name = f[/\[([^\]]+)\]/, 1] || "unknown"
-        stale << { name: name, age: age, entry: f }
-      end
-    end
-  end
-end
-
-# --- Detect current project ---
-
-current_project = nil
-if mode == "global"
-  projects_path = "#{store_root}/projects.yml"
-  if File.exist?(projects_path)
-    projects = YAML.safe_load(File.read(projects_path)) rescue {}
-    cwd = Dir.pwd
-    (projects["projects"] || {}).each do |slug, info|
-      project_path = File.expand_path(info["path"])
-      if cwd.start_with?(project_path)
-        current_project = { "slug" => slug, "parent" => info["parent"], "path" => project_path }
-        break
-      end
-    end
-  end
-end
-
-# --- Build context ---
-
-parts = []
-parts << "PLASTIC CONTINUE — The user wants to resume work.\n"
-
-if mode == "global" && current_project
-  parts << "Project: #{current_project["slug"]} (#{current_project["path"]})\n"
-  parts << "Governing intent: #{current_project["parent"]}\n" if current_project["parent"]
-end
-
-if active.any?
-  parts << "## Active Intents (work on these first)\n"
-  active.each { |a| parts << a }
-  parts << ""
-else
-  parts << "## No Active Intents\n"
-end
-
-if future.any?
-  parts << "## Future Intents (offer as next work)\n"
-  future.each { |f| parts << f }
-  parts << ""
-end
-
-if stale.any?
-  parts << "## Stale Future Intents\n"
-  parts << "These future intents have not been actioned. Ask the user what to do with each:\n"
-  stale.each do |s|
-    parts << "- #{s[:name]} (#{s[:age]} days old) — options: activate, abandon, or defer to agent (implement / research / ideate)"
-  end
-  parts << ""
-end
-
-parts << "Follow the plastic:continuing skill workflow.\n"
-parts << "1. If active intents exist: read their state and resume\n"
-parts << "2. If no active intents: present future intents as options\n"
-parts << "3. If stale intents exist: surface them and ask user to decide"
+context = cockpit.rstrip +
+  "\n\nFollow the plastic-continuing skill workflow to resume: " \
+  "if active intents exist, read their state and resume; otherwise offer the " \
+  "Value×Effort matrix items above, surfacing any stale (Nd) / ⚑ triage intents."
 
 payload = {
   "hookSpecificOutput" => {
     "hookEventName" => "UserPromptSubmit",
-    "additionalContext" => parts.join("\n")
+    "additionalContext" => context
   }
 }
 puts JSON.generate(payload)

package/scripts/hook-create-gate

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# PreToolUse create gate (intent 60b): validate the PROPOSED content of a Write
+# to an intent file before it lands. Fires when the target path is an intent file
+# inside its own equally-named directory (store/<id>--<slug>/<id>--<slug>.md). It
+# validates the proposed content from the hook payload (tool_input.content), NOT
+# the on-disk file (which does not exist yet at PreToolUse), using IntentValidator
+# for born-complete frontmatter plus the sanctioned section structure.
+#
+# It depends ONLY on the stdin path + content, never on the auto-bridge or
+# CLAUDE_SESSION_ID, so it runs unconditionally (headless / background sessions).
+# It validates ONLY the intent file, never sentinel placeholder lifecycle files
+# (spec.md/plan.md/etc.); the path matcher excludes them.
+#
+# Exit 0 = allow. Exit 2 = block (reason on stderr, shown to the agent).
+#
+# Reads the Claude Code PreToolUse payload as JSON on STDIN:
+#   { "tool_input": { "file_path": "...", "content": "..." } }
+# Empty / unparseable / non-matching path => exit 0 (cannot judge, allow).
+# Matching path but missing content => exit 2 (fail-safe: refuse to allow an
+# unvalidated intent write).
+
+require "json"
+require_relative "lib/intent_validator"
+
+raw = $stdin.read rescue nil
+exit 0 if raw.nil? || raw.strip.empty?
+
+payload = JSON.parse(raw) rescue nil
+exit 0 unless payload.is_a?(Hash)
+
+path = payload.dig("tool_input", "file_path") || payload.dig("tool_params", "file_path")
+exit 0 if path.nil? || path.to_s.strip.empty?
+
+# Precise path matcher: the target must be an intent file inside its own
+# equally-named dir. Never matches sibling lifecycle files (spec.md, etc.) or
+# unrelated store files.
+abs = File.expand_path(path)
+dir = File.dirname(abs)
+is_intent_file = dir.match?(%r{/store/[^/]+--[^/]+\z}) &&
+                 File.basename(abs) == "#{File.basename(dir)}.md"
+exit 0 unless is_intent_file
+
+content = payload.dig("tool_input", "content") || payload.dig("tool_params", "content")
+if content.nil?
+  $stderr.puts "PLASTIC CREATE GATE — #{File.basename(abs)}: cannot read proposed content; " \
+               "refusing to allow an unvalidated intent write."
+  exit 2
+end
+
+result = IntentValidator.validate_content(content)
+exit 0 if result[:ok]
+
+$stderr.puts "PLASTIC CREATE GATE — #{File.basename(abs)} is not a valid intent:"
+result[:errors].each { |e| $stderr.puts "  #{e}" }
+$stderr.puts "Create intents via new-intent / plastic-creating-intent; do not hand-author them."
+exit 2

package/scripts/hook-gate-check

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 # encoding: UTF-8
-# Usage: hook-gate-check <file_path>
+# Usage: hook-gate-check <file_path> [session_id]
 # PostToolUse gate enforcement for Plastic intent lifecycle.
 # Checks if a written file triggers a stage-transition gate.
 # Exit 0 = allow (optionally with transition context)
@@ -8,36 +8,51 @@
 
 require "json"
 require_relative "lib/bridge"
+require_relative "lib/intent_validator"
 
 file_path = ARGV[0]
 exit 0 unless file_path && !file_path.empty?
 
-# --- Find bridge file ---
+session = (ARGV[1] unless ARGV[1].to_s.empty?) || ENV["CLAUDE_SESSION_ID"]
 
-session = ENV["CLAUDE_SESSION_ID"]
-bridge_path = nil
-bridge_data = nil
+file_path_abs = File.expand_path(file_path)
 
-if session && !session.empty?
-  bridge_path = Bridge.path(session)
-  bridge_data = Bridge.read(session) if File.exist?(bridge_path)
+# --- Decoupled savepoint ledger (intent 34, hardened in intent 52) ---
+# The savepoint is derived purely from the file path's intent directory, BEFORE
+# any bridge resolution. A missing bridge must never skip the savepoint.
+intent_dir_abs = Bridge.intent_dir_for(file_path_abs)
+if intent_dir_abs
+  begin
+    Bridge.append_savepoint(intent_dir_abs, file_path_abs)
+  rescue StandardError
+    # ignore — rebuildable from disk
+  end
 end
 
-# Fallback: scan /tmp for most recent plastic bridge file
-unless bridge_data
-  candidates = Dir.glob("/tmp/plastic-*.json").reject { |f| f.end_with?(".tmp") }
-  if candidates.any?
-    bridge_path = candidates.max_by { |f| File.mtime(f) }
-    raw = JSON.parse(File.read(bridge_path)) rescue nil
-    if raw
-      session = raw["session"]
-      bridge_data = raw
-    end
+# --- Artifact-validity backstop (intent 4a1c1) ---
+# When the written file IS the intent file itself (the `<id>--<slug>.md` directly
+# inside `store/<id>--<slug>/`), run IntentValidator on it. This is headless-safe:
+# it depends only on the file path and disk, never on a bridge or session. In the
+# PostToolUse model the write has already happened, so we cannot prevent it; the
+# loud non-zero exit + stderr is the rejection signal. NOT for spec.md/plan.md/
+# checklist.md/outcome.md/savepoint.md — those are validated by the stage gates.
+if intent_dir_abs && File.basename(file_path_abs) == File.basename(Bridge.intent_file(intent_dir_abs))
+  result = IntentValidator.validate(intent_dir_abs)
+  unless result[:ok]
+    warn "PLASTIC ARTIFACT INVALID — #{File.basename(file_path_abs)} is not born complete:"
+    result[:missing].each { |field| warn "  missing required field: #{field}" }
+    result[:errors].each { |error| warn "  #{error}" }
+    warn "Fix the frontmatter; the intent is not valid until every required field is present and sources/chain are well-formed."
+    exit 1
   end
 end
 
-# No bridge = no active intent = no enforcement
-exit 0 unless bridge_data && session
+# --- Find bridge file ---
+bridge_data = Bridge.discover_bridge(session: session, cwd: Dir.pwd)
+
+# No bridge = no active intent = no stage enforcement. Savepoint already handled.
+exit 0 unless bridge_data
+session = bridge_data["session"]
 
 # --- Resolve intent directory ---
 
@@ -49,15 +64,14 @@ dir = intent_info["dir"]
 intent_dir = "#{store}/#{dir}"
 
 # Normalize both paths for comparison
-intent_dir_abs = File.expand_path(intent_dir)
-file_path_abs = File.expand_path(file_path)
+bridge_intent_dir_abs = File.expand_path(intent_dir)
 
 # Not inside intent dir = not our business
-exit 0 unless file_path_abs.start_with?("#{intent_dir_abs}/")
+exit 0 unless file_path_abs.start_with?("#{bridge_intent_dir_abs}/")
 
 # --- Determine if this is a stage-transition file ---
 
-relative = file_path_abs.sub("#{intent_dir_abs}/", "")
+relative = file_path_abs.sub("#{bridge_intent_dir_abs}/", "")
 basename = File.basename(file_path)
 
 stage_files = %w[spec.md plan.md checklist.md outcome.md]
@@ -66,7 +80,7 @@ is_action_file = relative.start_with?("actions/")
 
 if is_stage_file || is_action_file
   # Run gate check
-  error = Bridge.check_gate(intent_dir_abs, file_path_abs)
+  error = Bridge.check_gate(bridge_intent_dir_abs, file_path_abs)
 
   if error
     # Gate violation — block the write
@@ -83,11 +97,11 @@ if is_stage_file || is_action_file
 
   # Gate passed — update bridge with new stage
   old_stage = bridge_data["build"]["stage"]
-  new_stage = Bridge.derive_stage(intent_dir_abs)
-  new_missing = Bridge.missing_for_stage(new_stage) - Bridge.has_files(intent_dir_abs)
+  new_stage = Bridge.derive_stage(bridge_intent_dir_abs)
+  new_missing = Bridge.missing_for_stage(new_stage) - Bridge.has_files(bridge_intent_dir_abs)
 
   bridge_data["build"]["stage"] = new_stage
-  bridge_data["build"]["has"] = Bridge.has_files(intent_dir_abs)
+  bridge_data["build"]["has"] = Bridge.has_files(bridge_intent_dir_abs)
   bridge_data["build"]["missing"] = new_missing
   bridge_data["build"]["gate_failures"] = 0
   bridge_data["build"]["last_activity"] = Time.now.utc.iso8601
@@ -102,9 +116,9 @@ if is_stage_file || is_action_file
   stage_labels = { "what" => "What", "why" => "Why", "how" => "How", "exec" => "Exec", "done" => "Done" }
   next_hints = {
     "why" => "write spec.md",
-    "how" => "Why complete. Invoke plastic:auto to deliver autonomously, or write plan.md manually.",
-    "exec" => "How complete. Invoke plastic:auto or plastic:executing-plan to execute, or work through the checklist manually.",
-    "done" => "Exec complete. Intent must be completed now — write outcome.md, update INDEX.md, auto-commit. Use plastic:auto or do it manually."
+    "how" => "Why complete. Invoke plastic-auto to deliver autonomously, or write plan.md manually.",
+    "exec" => "How complete. Invoke plastic-auto or plastic-executing-plan to execute, or work through the checklist manually.",
+    "done" => "Exec complete. Intent must be completed now — write outcome.md, update INDEX.md, auto-commit. Use plastic-auto or do it manually."
   }
 
   context_parts = ["PLASTIC"]
@@ -129,7 +143,8 @@ if is_stage_file || is_action_file
   puts JSON.generate(payload)
   exit 0
 else
-  # Regular file in intent dir — just update last_activity
+  # Regular file in intent dir — just update last_activity. The savepoint for
+  # the What milestone was already handled above by the decoupled ledger write.
   bridge_data["build"]["last_activity"] = Time.now.utc.iso8601
   Bridge.write(session, bridge_data)
   exit 0

package/scripts/hook-qmd-search

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# qmd-first UserPromptSubmit hook (intent 66). Reads the prompt from stdin JSON,
+# delegates the decision to QmdHook.run under a hard timeout, and prints
+# hookSpecificOutput when there is something to inject/remind. Silent no-op (exit
+# 0) when qmd is absent, the prompt is trivial, or anything goes wrong. ARGV[0]
+# is the plastic_home (passed by the launcher); defaults to ~/.plastic.
+require "json"
+require "timeout"
+require_relative "lib/qmd_hook"
+
+raw = begin
+  STDIN.read
+rescue StandardError
+  ""
+end
+
+prompt = begin
+  parsed = JSON.parse(raw)
+  parsed.is_a?(Hash) ? parsed["user_prompt"].to_s : ""
+rescue StandardError
+  ""
+end
+
+plastic_home = (ARGV[0] && !ARGV[0].empty?) ? ARGV[0] : File.expand_path("~/.plastic")
+
+context = begin
+  Timeout.timeout(2) do
+    QmdHook.run(prompt: prompt, cwd: Dir.pwd, plastic_home: plastic_home)
+  end
+rescue Exception
+  nil
+end
+
+exit 0 if context.nil? || context.strip.empty?
+
+puts JSON.generate(
+  "hookSpecificOutput" => {
+    "hookEventName" => "UserPromptSubmit",
+    "additionalContext" => context,
+  }
+)