@zalom/plastic 1.0.0-alpha.28 → 1.0.0-alpha.29

package/hooks/code-gate

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

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/package.json

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

package/scripts/hook-auto-arm

@@ -26,8 +26,7 @@ if triggered
 end
 
 # --- 2. Standing gate reminder when armed and pre-How ---
-session = ENV["CLAUDE_SESSION_ID"]
-bridge_data = (session && !session.empty? && File.exist?(Bridge.path(session))) ? Bridge.read(session) : nil
+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"]

package/scripts/hook-bash-gate

@@ -28,22 +28,10 @@ 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 (mirror hook-code-gate resolution) ---
-session = ENV["CLAUDE_SESSION_ID"]
-bridge_data = nil
-
-if session && !session.empty?
-  bridge_data = Bridge.read(session) if File.exist?(Bridge.path(session))
-end
-
-unless bridge_data
-  candidates = Dir.glob("/tmp/plastic-*.json").reject { |f| f.end_with?(".tmp") }
-  if candidates.any?
-    newest = candidates.max_by { |f| File.mtime(f) }
-    bridge_data = JSON.parse(File.read(newest)) rescue nil
-  end
-end
-
+# --- 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)

package/scripts/hook-code-gate

@@ -14,22 +14,10 @@ require_relative "lib/bridge"
 file_path = ARGV[0]
 exit 0 unless file_path && !file_path.empty?
 
-# --- Load bridge (mirror hook-gate-check resolution) ---
-session = ENV["CLAUDE_SESSION_ID"]
-bridge_data = nil
-
-if session && !session.empty?
-  bridge_data = Bridge.read(session) if File.exist?(Bridge.path(session))
-end
-
-unless bridge_data
-  candidates = Dir.glob("/tmp/plastic-*.json").reject { |f| f.end_with?(".tmp") }
-  if candidates.any?
-    newest = candidates.max_by { |f| File.mtime(f) }
-    bridge_data = JSON.parse(File.read(newest)) rescue nil
-  end
-end
+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)

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)
@@ -12,32 +12,28 @@ require_relative "lib/bridge"
 file_path = ARGV[0]
 exit 0 unless file_path && !file_path.empty?
 
-# --- Find bridge file ---
-
-session = ENV["CLAUDE_SESSION_ID"]
-bridge_path = nil
-bridge_data = nil
+session = (ARGV[1] unless ARGV[1].to_s.empty?) || ENV["CLAUDE_SESSION_ID"]
 
-if session && !session.empty?
-  bridge_path = Bridge.path(session)
-  bridge_data = Bridge.read(session) if File.exist?(bridge_path)
-end
+file_path_abs = File.expand_path(file_path)
 
-# 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
+# --- 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
 
-# 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 +45,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 +61,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 +78,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
@@ -98,14 +93,6 @@ if is_stage_file || is_action_file
 
   Bridge.write(session, bridge_data)
 
-  # Cycle-step savepoint ledger (intent 34) — record this stage-file milestone.
-  # Best-effort: the ledger is derived sugar, so a failure must never block.
-  begin
-    Bridge.append_savepoint(intent_dir_abs, file_path_abs)
-  rescue StandardError
-    # ignore — rebuildable from disk
-  end
-
   # Build transition context
   stage_labels = { "what" => "What", "why" => "Why", "how" => "How", "exec" => "Exec", "done" => "Done" }
   next_hints = {
@@ -137,14 +124,8 @@ if is_stage_file || is_action_file
   puts JSON.generate(payload)
   exit 0
 else
-  # Regular file in intent dir — just update last_activity. The intent file
-  # (What milestone) lands here, so still offer it to the savepoint ledger;
-  # non-milestone files self-filter to a no-op (intent 34).
-  begin
-    Bridge.append_savepoint(intent_dir_abs, file_path_abs)
-  rescue StandardError
-    # ignore — rebuildable from disk
-  end
+  # 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/lib/bridge.rb

@@ -5,6 +5,7 @@ require "json"
 require "yaml"
 require "fileutils"
 require "tempfile"
+require "digest"
 
 module Bridge
   STAGES = %w[what why how exec done].freeze
@@ -14,26 +15,114 @@ module Bridge
     "#{intent_dir}/#{dir_name}.md"
   end
 
-  def self.path(session)
-    "/tmp/plastic-#{session}.json"
+  # Single source for the OS temp location holding bridge files. Lets every
+  # process (arm_auto, the gate hooks) agree, and lets tests fully isolate by
+  # pointing PLASTIC_TMP at a Dir.mktmpdir. This is OS-temp-location resolution,
+  # not a logic-config injection seam.
+  def self.tmp_dir
+    t = ENV["PLASTIC_TMP"]
+    (t.nil? || t.strip.empty?) ? "/tmp" : t
   end
 
-  def self.read(session)
-    p = path(session)
+  def self.path(session, tmp: tmp_dir)
+    "#{tmp}/plastic-#{session}.json"
+  end
+
+  # --- Session resolution (intent 52) ----------------------------------------
+
+  def self.blank?(value)
+    value.nil? || value.to_s.strip.empty?
+  end
+
+  # Deterministic, session-id-less bridge key derived from store + intent id.
+  # Stable across processes so a session-less arm and a later session-less
+  # gate-check resolve to the same bridge file.
+  def self.derive_key(store, intent_id)
+    "auto-" + Digest::SHA256.hexdigest("#{store}/#{intent_id}")[0, 10]
+  end
+
+  # Resolve a bridge session: first non-empty of explicit, CLAUDE_SESSION_ID,
+  # then a derived key. Never returns nil/empty. Whitespace-only counts as empty.
+  def self.resolve_session(explicit, intent_id:, store:)
+    return explicit.to_s.strip unless blank?(explicit)
+    env = ENV["CLAUDE_SESSION_ID"]
+    return env.to_s.strip unless blank?(env)
+    derive_key(store, intent_id)
+  end
+
+  # Walk up from file_path; return the first ancestor that looks like an intent
+  # directory (`.../store/<id>--<slug>`), else nil. Used to derive the savepoint
+  # target without needing a bridge. The input is always a file inside the intent
+  # dir (never the dir itself), so the walk-up starts at its parent.
+  def self.intent_dir_for(file_path)
+    dir = File.expand_path(file_path)
+    loop do
+      parent = File.dirname(dir)
+      break if parent == dir # reached filesystem root
+      dir = parent
+      return dir if dir.match?(%r{/store/[^/]+--[^/]+\z})
+    end
+    nil
+  end
+
+  # A bridge hash is usable iff it has a non-empty session and an intent Hash.
+  def self.bridge_valid?(data)
+    data.is_a?(Hash) && !blank?(data["session"]) && data["intent"].is_a?(Hash)
+  end
+
+  # Resolve the active bridge. Exact-session lookup first; otherwise scan tmp:
+  # for plastic-*.json, keep only valid bridges, prefer auto-armed, then prefer
+  # the one whose intent.store matches cwd, tie-break by newest mtime.
+  def self.discover_bridge(session:, cwd: Dir.pwd, tmp: tmp_dir)
+    if !blank?(session) && File.exist?(path(session, tmp: tmp))
+      exact = read(session, tmp: tmp)
+      return exact if bridge_valid?(exact)
+    end
+
+    candidates = Dir.glob(File.join(tmp, "plastic-*.json")).reject { |f| f.end_with?(".tmp") }
+    parsed = candidates.filter_map do |f|
+      data = (JSON.parse(File.read(f)) rescue nil)
+      next unless data && bridge_valid?(data)
+      { file: f, data: data, mtime: File.mtime(f) }
+    end
+    return nil if parsed.empty?
+
+    auto = parsed.select { |c| c[:data].dig("build", "auto") == true }
+    pool = auto.empty? ? parsed : auto
+
+    unless blank?(cwd)
+      cwd_abs = File.expand_path(cwd)
+      matching = pool.select do |c|
+        store = c[:data].dig("intent", "store").to_s
+        next false if store.empty?
+        store_abs = File.expand_path(store)
+        cwd_abs == store_abs ||
+          cwd_abs.start_with?("#{store_abs}/") ||
+          store_abs.start_with?("#{cwd_abs}/")
+      end
+      pool = matching unless matching.empty?
+    end
+
+    pool.max_by { |c| c[:mtime] }&.fetch(:data)
+  end
+
+  def self.read(session, tmp: tmp_dir)
+    p = path(session, tmp: tmp)
     return nil unless File.exist?(p)
     JSON.parse(File.read(p))
   rescue JSON::ParserError
     nil
   end
 
-  def self.write(session, data)
-    p = path(session)
+  def self.write(session, data, tmp: tmp_dir)
+    raise ArgumentError, "bridge session must be present" if blank?(session)
+    p = path(session, tmp: tmp)
     # Atomic write: tmp file + rename to prevent partial reads
-    tmp = "#{p}.tmp.#{Process.pid}"
-    File.write(tmp, JSON.pretty_generate(data.merge("updated_at" => Time.now.utc.iso8601)))
-    File.rename(tmp, p)
+    tmp_file = "#{p}.tmp.#{Process.pid}"
+    File.write(tmp_file, JSON.pretty_generate(data.merge("updated_at" => Time.now.utc.iso8601)))
+    File.rename(tmp_file, p)
   rescue => e
-    File.delete(tmp) if tmp && File.exist?(tmp)
+    File.delete(tmp_file) if tmp_file && File.exist?(tmp_file)
     raise e
   end
 
@@ -227,9 +316,13 @@ module Bridge
   # Arm auto mode for a session+intent. Works even when no bridge exists yet
   # (mid-session intent creation). Re-derives intent state, then sets build.auto.
   def self.arm_auto(session, intent_id:, intent_dir:, store:, name:)
-    data = derive(session, intent_id: intent_id, intent_dir: intent_dir, store: store, name: name)
+    key = resolve_session(session, intent_id: intent_id, store: store)
+    if blank?(session) && blank?(ENV["CLAUDE_SESSION_ID"])
+      $stderr.puts "plastic: no session id available; arming auto with derived bridge key #{key}"
+    end
+    data = derive(key, intent_id: intent_id, intent_dir: intent_dir, store: store, name: name)
     data["build"]["auto"] = true
-    write(session, data)
+    write(key, data)
     data
   end
 

package/skills/auto/SKILL.md

@@ -40,8 +40,9 @@ ruby -r ~/.plastic/scripts/lib/bridge -e \
 ```
 
 Replace `<ID>`, `<STORE>` (e.g. `~/.plastic/projects/<slug>/store` or `~/.plastic/store`),
-`<dir>` (the `ID--slug` directory), and `<name>`. If `CLAUDE_SESSION_ID` is unset, arming
-is best-effort — proceed regardless; the gate simply won't engage.
+`<dir>` (the `ID--slug` directory), and `<name>`. If `CLAUDE_SESSION_ID` is unset, `arm_auto`
+falls back to a deterministic derived bridge key (a hash of the store and intent id), so the
+gate still engages; arming prints a one-line notice to stderr in that case.
 
 **Hard rule for the rest of this run:** do NOT edit project code (anything outside the
 intent directory / `~/.plastic/`) until `plan.md` AND `checklist.md` exist for the intent.