@zalom/plastic 1.8.0 → 1.10.0

package/scripts/exec-worktree

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# exec-worktree (intent 213, group 2) - finish an intent's code worktree: an order
+# precondition, then Worktree.finish (delivered merges + removes, abandoned removes only).
+#
+# Usage:
+#   exec-worktree --store <path> --id <intent_id> --home <plastic_home> \
+#                 --disposition delivered|abandoned [--session <session_id>]
+#
+# --home accepts either spelling: the OS-home level (the PARENT of .plastic) or the
+# .plastic directory itself. When the given path's basename is literally .plastic, its
+# dirname is used instead. Worktree.finish's home: keyword always wants the OS-home
+# level (Worktree.home_from_store, scripts/lib/worktree.rb:90); this script normalizes
+# both spellings to that so either caller convention works.
+#
+# Steps performed:
+#   0. Resolve inputs: the intent dir, normalize --home, resolve the calling session
+#      (--session, else CLAUDE_CODE_SESSION_ID, else the existing delivery.lock's own
+#      recorded owner_session when non-blank, else nil; unlike start-intent, the
+#      lock-owner fallback IS used here, matching end-intent's teardown resolution order).
+#      Load the bridge (Bridge.read); a nil bridge means there is nothing to finish (exit
+#      0, loud: the worktree this intent provisioned, if any, was NOT removed). No
+#      worktree.code on the bridge means nothing was provisioned (exit 0).
+#   1. The order precondition (delivered only): calls the EXISTING
+#      Bridge.code_gate_decision predicate exactly as it exists. On an auto bridge that
+#      has not reached How, this BLOCKS (exit 2). Bridge.code_gate_decision returns nil
+#      UNCONDITIONALLY on a guided bridge (build.auto != true), so on a guided bridge
+#      this precondition is ADVISORY ONLY: it always passes and the run proceeds. This
+#      script is NOT the enforcement point either way; the hook layer
+#      (scripts/lib/bridge.rb code_gate_decision, wired through scripts/lib/edit_gates.rb)
+#      remains the actual gate. See scripts/lib/exec_worktree.rb's module doc for why the
+#      auto-only condition is never relaxed and never duplicated here.
+#   2. The dirty-worktree guard (delivered only): git status --porcelain on the code
+#      worktree. Not clean, or the check itself fails, fails CLOSED (exit 3), mirroring
+#      end-intent's dirty-worktree handling. abandoned skips this guard entirely: the
+#      branch survives and can be reclaimed, so a dirty worktree is not a reason to
+#      refuse.
+#   3. Finish: Worktree.finish(bridge_data, home:, runner:, merge: disposition ==
+#      "delivered"). Worktree.finish is fail-open and never raises, so failure is
+#      detected by checking, for a delivered disposition only, whether the worktree
+#      directory still exists on disk afterward (release removes it on success).
+#
+# No test suite is run by this script, in any form. verify-intent owns test execution;
+# one concern per script (spec D8).
+#
+# Exit codes:
+#   0  finished (merged or removed per disposition), or nothing to finish (no bridge
+#      resolved, or no code worktree recorded on the bridge)
+#   1  usage or path-resolution failure
+#   2  the order precondition blocked a delivered disposition (auto bridge, How not
+#      reached)
+#   3  the worktree is not clean, or the merge/removal did not complete (delivered only)
+#   4  lock or session resolution failure
+
+require_relative "lib/exec_worktree"
+
+def parse_args(argv)
+  opts = { store: nil, id: nil, home: nil, disposition: nil, session: nil }
+  i = 0
+  while i < argv.length
+    arg = argv[i]
+    case arg
+    when "--store"       then opts[:store] = argv[i += 1]
+    when "--id"          then opts[:id] = argv[i += 1]
+    when "--home"        then opts[:home] = argv[i += 1]
+    when "--disposition" then opts[:disposition] = argv[i += 1]
+    when "--session"     then opts[:session] = argv[i += 1]
+    else
+      usage_abort("unknown argument #{arg.inspect}")
+    end
+    i += 1
+  end
+  opts
+end
+
+def usage
+  "usage: exec-worktree --store <store_path> --id <intent_id> --home <plastic_home> " \
+    "--disposition delivered|abandoned [--session <session_id>]"
+end
+
+def usage_abort(message)
+  warn "exec-worktree: #{message}"
+  warn usage
+  exit 1
+end
+
+def main(argv)
+  opts = parse_args(argv)
+
+  result = ExecWorktree.run(
+    store: opts[:store], id: opts[:id], home: opts[:home], disposition: opts[:disposition],
+    session: opts[:session], env_session: ENV["CLAUDE_CODE_SESSION_ID"]
+  )
+
+  Array(result[:stderr]).each { |line| warn line }
+  warn usage if result[:exit_code] == ExecWorktree::EXIT_USAGE
+  Array(result[:stdout]).each { |line| puts line }
+  exit result[:exit_code]
+end
+
+main(ARGV) if $PROGRAM_NAME == __FILE__

package/scripts/hash-intent

@@ -13,7 +13,7 @@ fi
 
 # Try Ruby first (macOS/Linux default)
 if command -v ruby &>/dev/null; then
-  ruby -r digest -e 'puts Digest::SHA256.hexdigest(ARGV[0]).to_i(16).to_s(36)[0,6]' "$INTENT_NAME"
+  env -u RUBYOPT ruby -r digest -e 'puts Digest::SHA256.hexdigest(ARGV[0]).to_i(16).to_s(36)[0,6]' "$INTENT_NAME"
   exit 0
 fi
 

package/scripts/hook-bash-gate

@@ -55,5 +55,24 @@ bridge_data = Bridge.discover_bridge(session: session, cwd: cwd)
 reason = Bridge.bash_gate_decision(bridge_data, command, cwd: cwd, session: session)
 exit 0 unless reason
 
+# Block log (intent 229): one six-field TSV line, hand-rolled here exactly as
+# the escape write above is, so this script keeps requiring only lib/bridge and
+# pays no extra load on every Bash tool call. Best-effort: the block applies
+# regardless.
+begin
+  require "fileutils"
+  require "time"
+  blocklog = File.join(Dir.home, ".plastic", ".cache", "gate-blocks.log")
+  FileUtils.mkdir_p(File.dirname(blocklog))
+  intent_id = bridge_data.is_a?(Hash) ? bridge_data.dig("intent", "id").to_s : ""
+  File.open(blocklog, "a") do |io|
+    io.puts([Time.now.utc.iso8601, "bash-gate", session.to_s, intent_id,
+             command.to_s.gsub(/\s+/, " ").strip,
+             reason.to_s.gsub(/\s+/, " ").strip].join("\t"))
+  end
+rescue StandardError
+  # the block still applies; logging is best-effort
+end
+
 $stderr.puts "PLASTIC GATE — #{reason}"
 exit 2

package/scripts/hook-code-gate

@@ -2,7 +2,7 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-# Usage: hook-code-gate <file_path>
+# Usage: hook-code-gate <file_path> [session_id] [content]
 # PreToolUse gate. Composes two independent block rules; EITHER blocks the edit:
 #   - Stage rule (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.
@@ -12,39 +12,27 @@
 #
 # Exit 0 = allow. Exit 2 = block (reason on stderr, shown to the agent).
 # No bridge = allow. Each rule fails open on its own conditions (see bridge.rb).
+#
+# Thin CLI wrapper (intent 244): the gate logic itself lives in
+# scripts/lib/edit_gates.rb, shared with the merged Claude dispatcher
+# (scripts/hook-edit-gates) and, since intent 251, the merged Codex dispatcher
+# (scripts/lib/codex_edit_gates.rb). This wrapper has no production caller on
+# either harness anymore; it remains as the per-gate isolation surface for the
+# hook test suite.
 
-require_relative "lib/bridge"
+require_relative "lib/edit_gates"
 
 file_path = ARGV[0]
 exit 0 unless file_path && !file_path.empty?
 
 session = (ARGV[1] unless ARGV[1].to_s.empty?) || ENV["CLAUDE_CODE_SESSION_ID"]
 
-# Auditable escape (intent 150, mirrors the Bash gate's intent 108 D7): a trailing
-# `# plastic-ok` in the new Write/Edit content allows the edit and logs it, so a
-# deliberately sanctioned code edit no longer needs the Bash-funneling workaround.
-new_content = ARGV[2]
-if new_content && Bridge::PLASTIC_OK_RE.match?(new_content.chomp)
-  begin
-    require "fileutils"
-    log = File.join(Dir.home, ".plastic", ".cache", "gate-escapes.log")
-    FileUtils.mkdir_p(File.dirname(log))
-    File.open(log, "a") do |io|
-      io.puts("#{Time.now.utc.iso8601}\t#{session}\t#{file_path}")
-    end
-  rescue StandardError
-    # the escape still applies; logging is best-effort
-  end
-  exit 0
-end
-
-# --- Load bridge (shared resolution; stdin session_id -> CLAUDE_CODE_SESSION_ID -> /tmp scan) ---
-bridge_data = Bridge.discover_bridge(session: session, cwd: file_path, edited_path: file_path)
-exit 0 unless bridge_data
-
-reason = Bridge.code_gate_decision(bridge_data, file_path) ||
-         Bridge.worktree_gate_decision(bridge_data, file_path, current_session: session)
-exit 0 unless reason
+ctx = EditGates::Context.new(
+  tool_name: "Write", session: session, gate_path: file_path, file_path: file_path,
+  content: ARGV[2], harness: "claude",
+)
 
-$stderr.puts "PLASTIC GATE — #{reason}"
+outcome = EditGates.code_gate(ctx)
+exit 0 unless outcome
+outcome.lines.each { |line| $stderr.puts line }
 exit 2

package/scripts/hook-continue

@@ -15,7 +15,7 @@ exit 0 unless index_path && File.exist?(index_path)
 dashboard = File.expand_path("dashboard.rb", __dir__)
 exit 0 unless File.exist?(dashboard)
 
-cockpit, _err, status = Open3.capture3("ruby", dashboard, "continue")
+cockpit, _err, status = Open3.capture3({"RUBYOPT" => nil}, "ruby", dashboard, "continue")
 exit 0 unless status.success? && !cockpit.strip.empty?
 
 context = cockpit.rstrip +
@@ -36,7 +36,7 @@ payload = {
 # 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")
+  data_json, _data_err, data_status = Open3.capture3({"RUBYOPT" => nil}, "ruby", dashboard, "continue", "--data")
   if data_status.success?
     banner = DashboardBanner.render(JSON.parse(data_json))
     payload["systemMessage"] = banner if banner

package/scripts/hook-create-gate

@@ -26,9 +26,18 @@
 #   Pathless MCP mutation:  validate the CURRENT on-disk file (the PostToolUse
 #                           gate-check backstop validates the result); a
 #                           missing file blocks (fail-safe).
+#
+# Thin CLI wrapper (intent 244): the gate logic itself lives in
+# scripts/lib/edit_gates.rb, shared with the merged Claude dispatcher
+# (scripts/hook-edit-gates) and, since intent 251, the merged Codex dispatcher
+# (scripts/lib/codex_edit_gates.rb). This wrapper has no production caller on
+# either harness anymore; it remains as the per-gate isolation surface for the
+# hook test suite. Deliberately WITHOUT a top-level rescue, matching this
+# script's behavior before the extraction: an internal exception here has
+# never been caught.
 
 require "json"
-require_relative "lib/intent_validator"
+require_relative "lib/edit_gates"
 
 raw = $stdin.read rescue nil
 exit 0 if raw.nil? || raw.strip.empty?
@@ -36,60 +45,7 @@ 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
-
-input = payload["tool_input"] || payload["tool_params"] || {}
-content = input["content"]
-old_string = input["old_string"]
-
-def block!(lines)
-  Array(lines).each { |l| $stderr.puts l }
-  exit 2
-end
-
-result =
-  if !content.nil?
-    # Write: validate the proposed content (intent 60b, unchanged).
-    IntentValidator.validate_content(content)
-  elsif !old_string.nil?
-    # Edit (intent 108, D7): simulate the replacement on the on-disk file and
-    # validate the RESULT, so an Edit can no longer sneak an intent file past
-    # the validator.
-    unless File.exist?(abs)
-      block!("PLASTIC CREATE GATE — #{File.basename(abs)} does not exist; " \
-             "create intents via new-intent / plastic-intent-creating.")
-    end
-    current = File.read(abs)
-    unless current.include?(old_string)
-      exit 0 # the Edit tool itself will fail; nothing lands, nothing to judge
-    end
-    simulated = input["replace_all"] ? current.gsub(old_string, input["new_string"].to_s)
-                                     : current.sub(old_string, input["new_string"].to_s)
-    IntentValidator.validate_content(simulated)
-  else
-    # Pathless mutation (MCP symbolic edits): the proposal is not visible at
-    # PreToolUse. Judge the CURRENT file: valid -> allow (the PostToolUse
-    # gate-check backstop validates the result), invalid/missing -> block.
-    unless File.exist?(abs)
-      block!("PLASTIC CREATE GATE — #{File.basename(abs)}: cannot read proposed " \
-             "content and no file exists; refusing to allow an unvalidated intent write.")
-    end
-    IntentValidator.validate_content(File.read(abs))
-  end
-
-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-intent-creating; do not hand-author them."
+outcome = EditGates.create_gate(EditGates.context_from(payload))
+exit 0 unless outcome
+outcome.lines.each { |line| $stderr.puts line }
 exit 2

package/scripts/hook-edit-gates

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# The merged Claude PreToolUse edit-path dispatcher (intent 244). One registered
+# hook, one Ruby process, one stdin parse, five gates in-process, in the fixed
+# order savepoint-pre, lock-gate, code-gate, links-gate, create-gate (spec D-a).
+# The first deny ends evaluation and its own shape is reproduced exactly: stderr
+# plus exit 2 for code-gate/links-gate/create-gate, stdout permissionDecision
+# JSON plus exit 0 for lock-gate (spec D-b). savepoint-pre runs first so its
+# `started` ledger append stays unconditional, including on a call another gate
+# then blocks (spec D-c).
+#
+# Fail-open everywhere (spec D-i): each gate runs inside its own rescue in
+# EditGates.dispatch, and this file's top level rescues to exit 0, so a gate bug
+# never denies and never silences a sibling gate.
+#
+# LOAD-BEARING SHAPE: doctor's claude_hooks_implemented_check reads THIS FILE as
+# plain text and extracts the `when "<gate>"` labels of the `case gate` statement
+# below, because a script with top-level side effects can never be required to
+# introspect it (the same technique intent 200 used for scripts/codex-hook). If
+# the case statement is reshaped, update that check in scripts/doctor.rb in the
+# same change, or it will fail loudly by design.
+
+require "json"
+require_relative "lib/edit_gates"
+
+def route(gate, ctx)
+  case gate
+  when "savepoint-pre" then EditGates.savepoint_pre(ctx)
+  when "lock-gate"     then EditGates.lock_gate(ctx)
+  when "code-gate"     then EditGates.code_gate(ctx)
+  when "links-gate"    then EditGates.links_gate(ctx)
+  when "create-gate"   then EditGates.create_gate(ctx)
+  end
+end
+
+begin
+  raw = begin
+    $stdin.read
+  rescue StandardError
+    nil
+  end
+  exit 0 if raw.nil? || raw.strip.empty?
+
+  payload = begin
+    JSON.parse(raw)
+  rescue StandardError
+    nil
+  end
+  exit 0 unless payload.is_a?(Hash)
+
+  exit EditGates.dispatch(ctx: EditGates.context_from(payload), route: method(:route))
+rescue StandardError => e
+  # Dispatcher-internal failure: never impersonate a deny (spec D-i).
+  $stderr.puts "plastic edit-gates error: #{e.message}"
+  exit 0
+end

package/scripts/hook-gate-check

@@ -99,6 +99,23 @@ if is_stage_file || is_action_file
   error = Bridge.check_gate(bridge_intent_dir_abs, file_path_abs)
 
   if error
+    # Block log (intent 229): same hand-rolled best-effort write as
+    # hook-bash-gate's; this script keeps its current requires.
+    begin
+      require "fileutils"
+      require "time"
+      blocklog = File.join(Dir.home, ".plastic", ".cache", "gate-blocks.log")
+      FileUtils.mkdir_p(File.dirname(blocklog))
+      File.open(blocklog, "a") do |io|
+        io.puts([Time.now.utc.iso8601, "gate-check", session.to_s,
+                 Bridge.intent_id_from_dir(bridge_intent_dir_abs).to_s,
+                 file_path_abs.to_s.gsub(/\s+/, " ").strip,
+                 error.to_s.gsub(/\s+/, " ").strip].join("\t"))
+      end
+    rescue StandardError
+      # the block still applies; logging is best-effort
+    end
+
     # Gate violation — block the write
     bridge_data["build"]["gate_failures"] = (bridge_data["build"]["gate_failures"] || 0) + 1
     Bridge.write(session, bridge_data)

package/scripts/hook-links-gate

@@ -13,9 +13,16 @@
 #   { "tool_input": { "file_path":, "content": | "old_string"/"new_string"/"replace_all": } }
 # Exit 0 = allow (including every "cannot judge" case). Exit 2 = deny (message
 # on stderr).
+#
+# Thin CLI wrapper (intent 244): the gate logic itself lives in
+# scripts/lib/edit_gates.rb, shared with the merged Claude dispatcher
+# (scripts/hook-edit-gates) and, since intent 251, the merged Codex dispatcher
+# (scripts/lib/codex_edit_gates.rb). This wrapper has no production caller on
+# either harness anymore; it remains as the per-gate isolation surface for the
+# hook test suite.
 
 require "json"
-require_relative "lib/links_gate"
+require_relative "lib/edit_gates"
 
 begin
   raw = begin
@@ -32,36 +39,9 @@ begin
   end
   exit 0 unless payload.is_a?(Hash)
 
-  path = payload.dig("tool_input", "file_path") || payload.dig("tool_params", "file_path")
-  exit 0 if path.to_s.strip.empty?
-
-  abs = File.expand_path(path)
-  exit 0 unless LinksGate.intent_file?(abs)
-
-  input = payload["tool_input"] || payload["tool_params"] || {}
-  content = input["content"]
-  old_string = input["old_string"]
-
-  before_content = File.exist?(abs) ? File.read(abs) : ""
-
-  after_content =
-    if !content.nil?
-      content
-    elsif !old_string.nil?
-      exit 0 unless before_content.include?(old_string) # the Edit tool itself will fail; nothing to judge
-      input["replace_all"] ? before_content.gsub(old_string, input["new_string"].to_s)
-                            : before_content.sub(old_string, input["new_string"].to_s)
-    else
-      exit 0 # pathless mutation (no visible proposal); cannot judge, allow
-    end
-
-  plastic_home = ENV.fetch("PLASTIC_HOME") { File.join(Dir.home, ".plastic") }
-
-  reason = LinksGate.decision(file_path: abs, before_content: before_content,
-                               after_content: after_content, plastic_home: plastic_home)
-  exit 0 unless reason
-
-  $stderr.puts reason
+  outcome = EditGates.links_gate(EditGates.context_from(payload))
+  exit 0 unless outcome
+  outcome.lines.each { |line| $stderr.puts line }
   exit 2
 rescue => e
   # Hook-internal failure only: do NOT impersonate a user-deny. Log and fail open

package/scripts/hook-lock-gate

@@ -8,9 +8,15 @@
 # gated here (D2). Emits the PreToolUse JSON deny contract at exit 0; reserves
 # non-zero exit for hook-internal errors only. Matcher Write|Edit|NotebookEdit, so
 # reads never reach here.
-require "json"
-require_relative "lib/bridge"
-require_relative "lib/lock"
+#
+# Thin CLI wrapper (intent 244): the gate logic itself lives in
+# scripts/lib/edit_gates.rb, shared with the merged Claude dispatcher
+# (scripts/hook-edit-gates) and, since intent 251, the merged Codex dispatcher
+# (scripts/lib/codex_edit_gates.rb). This wrapper has no production caller on
+# either harness anymore; it remains as the per-gate isolation surface for the
+# hook test suite.
+
+require_relative "lib/edit_gates"
 
 begin
   file_path = ARGV[0]
@@ -18,66 +24,19 @@ begin
   session = (ARGV[1] unless ARGV[1].to_s.empty?) || ENV["CLAUDE_CODE_SESSION_ID"]
   # Usage: hook-lock-gate <file_path> [session_id] [harness]. Claude's own bash
   # shim never passes a third arg, so harness falls through to Lock's default
-  # (claude, slash form); scripts/codex-hook is the only caller that passes
-  # "codex" here (intent 201 D2).
+  # (claude, slash form). Since intent 251 the merged Codex library
+  # (scripts/lib/codex_edit_gates.rb) sets harness: "codex" directly on the
+  # Context it builds; no caller of this wrapper passes "codex" anymore.
   harness = (ARGV[2] unless ARGV[2].to_s.empty?) || "claude"
 
-  bridge_data = Bridge.discover_bridge(session: session, cwd: Dir.pwd)   # nil = no bridge cache
-  reason = Bridge.lock_gate_decision(bridge_data, file_path, session: session, harness: harness)
-  unless reason
-    # Allow path: refresh the lease for the session that holds this target's
-    # lock (owner or delegate). Best-effort, never blocks.
-    begin
-      dir = Bridge.intent_dir_for(file_path)
-      Lock.heartbeat(dir, session: session) if dir && !session.to_s.empty?
-    rescue StandardError
-      # ignore
-    end
-
-    # Second, independent gate (intent 111 D7): the artifact-grain claim.
-    # Composes UNDER the delivery lock above; only reached once the delivery
-    # lock already allows. Dormant (nil) unless a claim file exists for this
-    # artifact, so AC7 (existing single-owner flows) is unaffected.
-    begin
-      dir = Bridge.intent_dir_for(file_path)
-      artifact = File.basename(file_path) if dir
-      if dir && artifact
-        claim_reason = Claim.claim_gate_reason(dir, artifact, session: session, harness: harness)
-        if claim_reason
-          print JSON.generate(
-            "hookSpecificOutput" => {
-              "hookEventName" => "PreToolUse",
-              "permissionDecision" => "deny",
-              "permissionDecisionReason" => claim_reason,
-            }
-          )
-          exit 0
-        end
-
-        # Fail-open surface (AC3): allow, but make the yielded/stale claim visible.
-        if Claim.fail_open?(dir, artifact)
-          $stderr.puts "plastic claim gate: unresolvable claim on #{artifact} in " \
-                       "intent #{Bridge.intent_id_from_dir(dir)} yielded; write " \
-                       "proceeds (see /plastic-lock status)"
-        end
-
-        # Heartbeat the session's own claim on the allow path (best-effort).
-        Claim.heartbeat(dir, artifact, session: session) rescue nil
-      end
-    rescue StandardError
-      # ignore: a claim-gate bug must never block a write (fail open)
-    end
-
-    exit 0
-  end
-
-  print JSON.generate(
-    "hookSpecificOutput" => {
-      "hookEventName" => "PreToolUse",
-      "permissionDecision" => "deny",
-      "permissionDecisionReason" => reason   # "run /plastic-intent-starting to lock and begin"
-    }
+  ctx = EditGates::Context.new(
+    tool_name: "Write", session: session, gate_path: file_path, file_path: file_path,
+    harness: harness,
   )
+
+  outcome = EditGates.lock_gate(ctx)
+  exit 0 unless outcome
+  print outcome.stdout
   exit 0
 rescue => e
   # Hook-internal failure only: do NOT impersonate a user-deny. Log and fail open

package/scripts/hook-power-tools

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# power-tools UserPromptSubmit hook (intents 66, 66b, 187, 246). Emits the
+# PowerTools mandate, one recommendation line per present tool, as
+# hookSpecificOutput. Silent no-op (exit 0) when no power tool is present or
+# anything goes wrong. It parses no prompt: the mandate depends on tool presence
+# alone, so there is nothing to gate on prompt triviality. Intent 246 removed the
+# qmd hit search this hook used to run first.
+require "json"
+require "timeout"
+require_relative "lib/qmd_hook"
+
+# Drain stdin so the caller's write never blocks or breaks on a closed pipe. The
+# payload is deliberately not parsed.
+begin
+  STDIN.read
+rescue StandardError
+  nil
+end
+
+context = begin
+  Timeout.timeout(2) do
+    QmdHook.run(cwd: Dir.pwd)
+  end
+rescue Exception
+  nil
+end
+
+exit 0 if context.nil? || context.strip.empty?
+
+puts JSON.generate(
+  "hookSpecificOutput" => {
+    "hookEventName" => "UserPromptSubmit",
+    "additionalContext" => context,
+  }
+)

package/scripts/hook-savepoint-pre

@@ -13,20 +13,20 @@
 # write: any non-match or failure exits 0. The append is idempotent and only
 # fires while the stage is genuinely starting (the artifact is not yet a real,
 # non-placeholder file), so re-edits add nothing.
+#
+# Thin CLI wrapper (intent 244): the gate logic itself lives in
+# scripts/lib/edit_gates.rb, shared with the merged Claude dispatcher
+# (scripts/hook-edit-gates) and, since intent 251, the merged Codex dispatcher
+# (scripts/lib/codex_edit_gates.rb). This wrapper has no production caller on
+# either harness anymore; it remains as the per-gate isolation surface for the
+# hook test suite.
 
-require_relative "lib/bridge"
+require_relative "lib/edit_gates"
 
 file_path = ARGV[0]
 exit 0 if file_path.nil? || file_path.empty?
 
-file_path_abs = File.expand_path(file_path)
-intent_dir = Bridge.intent_dir_for(file_path_abs)
-exit 0 unless intent_dir
-
-begin
-  Bridge.append_started_savepoint(intent_dir, file_path_abs)
-rescue StandardError
-  # best-effort; the ledger is rebuildable and the post line still lands
-end
-
+EditGates.savepoint_pre(
+  EditGates::Context.new(tool_name: "Write", file_path: file_path, harness: "claude")
+)
 exit 0