@zalom/plastic 1.14.0 → 2.0.0-alpha.1

package/scripts/hook-create-gate

@@ -1,51 +0,0 @@
-#!/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 any
-# 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).
-# Three payload shapes on a matching path (intent 108, D7):
-#   Write (content):        validate the proposed content.
-#   Edit (old_string):      simulate the replacement on the on-disk file and
-#                           validate the RESULT; a missing file blocks.
-#   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/edit_gates"
-
-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)
-
-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

@@ -1,58 +0,0 @@
-#!/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-future-intent-check

@@ -1,90 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-# Usage: hook-future-intent-check <store_root> <message>
-# Outputs hook JSON when the user's message matches future intent keywords.
-# Exits silently if no matches.
-
-require "json"
-require "yaml"
-
-store_root, message = ARGV
-exit 0 unless store_root && message
-
-index_path = "#{store_root}/INDEX.md"
-exit 0 unless File.exist?(index_path)
-
-# --- Find future intent dirs ---
-
-lines = File.readlines(index_path)
-future_dirs = []
-section = nil
-
-lines.each do |line|
-  section = :future if line.start_with?("## Future")
-  section = nil if line.start_with?("## ") && !line.start_with?("## Future")
-  next unless section == :future && line.strip.start_with?("- [")
-
-  if line =~ /store\/([\w-]+)\//
-    future_dirs << $1
-  end
-end
-
-exit 0 if future_dirs.empty?
-
-# --- Match keywords against message ---
-
-matches = []
-message_words = message.split(/\W+/).reject { |w| w.length < 4 }
-
-future_dirs.each do |dir|
-  intent_path = "#{store_root}/store/#{dir}/#{dir}.md"
-  next unless File.exist?(intent_path)
-
-  content = File.read(intent_path)
-
-  tags = []
-  if content =~ /^tags:\s*\[([^\]]+)\]/
-    tags = $1.split(",").map(&:strip).map(&:downcase)
-  end
-
-  intent_name = ""
-  if content =~ /^intent:\s*["']?(.+?)["']?\s*$/
-    intent_name = $1.downcase
-  end
-
-  intent_id = ""
-  if content =~ /^id:\s*["']?([a-z0-9]+)["']?\s*$/
-    intent_id = $1
-  end
-
-  keywords = tags + intent_name.split(/\W+/).reject { |w| w.length < 4 }
-  keywords = keywords.map(&:downcase).uniq
-
-  matched_keywords = keywords.select { |kw| message.include?(kw) }
-  name_matches = message_words.select { |w| intent_name.include?(w) }
-  matched_keywords = (matched_keywords + name_matches).uniq
-
-  if matched_keywords.length >= 1
-    index_line = lines.find { |l| l.include?(dir) }&.strip || "#{intent_id} — #{intent_name}"
-    matches << { "index_line" => index_line, "keywords" => matched_keywords }
-  end
-end
-
-exit 0 if matches.empty?
-
-# --- Build context ---
-
-parts = []
-parts << "PLASTIC — Future intents related to this message:\n"
-matches.each do |m|
-  parts << "#{m["index_line"]} (matched: #{m["keywords"].join(", ")})"
-end
-parts << "\nConsider asking the user if they want to activate any of these, or note the connection."
-
-payload = {
-  "hookSpecificOutput" => {
-    "hookEventName" => "UserPromptSubmit",
-    "additionalContext" => parts.join("\n")
-  }
-}
-puts JSON.generate(payload)

package/scripts/hook-gate-check

@@ -1,169 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-# 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)
-# Exit 2 = block (gate violation)
-
-require "json"
-require_relative "lib/bridge"
-require_relative "lib/intent_validator"
-require_relative "lib/lock"
-
-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"]
-
-file_path_abs = File.expand_path(file_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)
-    # When checklist.md lands, How ends and Exec begins: emit the `Exec started`
-    # companion in the same event (intent 81). Guard on a real (non-placeholder)
-    # checklist so a scaffold sentinel does not trip it.
-    if File.basename(file_path_abs) == "checklist.md" && Bridge.stage_file_present?(file_path_abs)
-      Bridge.append_exec_started(intent_dir_abs)
-    end
-  rescue StandardError
-    # ignore — rebuildable from disk
-  end
-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
-
-# --- 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 ---
-
-intent_info = bridge_data["intent"]
-exit 0 unless intent_info
-
-store = intent_info["store"]
-dir = intent_info["dir"]
-intent_dir = "#{store}/#{dir}"
-
-# Normalize both paths for comparison
-bridge_intent_dir_abs = File.expand_path(intent_dir)
-
-# Lease heartbeat (intent 108, D1): every write by the session that owns (or
-# delegates under) the lock refreshes the delivery.lock mtime. Best-effort:
-# a heartbeat failure must never break the gate hook.
-begin
-  Lock.heartbeat(bridge_intent_dir_abs, session: session)
-rescue StandardError
-  # ignore
-end
-
-# Not inside intent dir = not our business
-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("#{bridge_intent_dir_abs}/", "")
-basename = File.basename(file_path)
-
-stage_files = %w[spec.md plan.md checklist.md outcome.md]
-is_stage_file = stage_files.include?(basename)
-is_action_file = relative.start_with?("actions/")
-
-if is_stage_file || is_action_file
-  # Run gate check
-  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)
-
-    payload = {
-      "decision" => "block",
-      "reason" => "PLASTIC GATE — #{error}"
-    }
-    puts JSON.generate(payload)
-    exit 2
-  end
-
-  # Gate passed — update bridge with new stage
-  old_stage = bridge_data["build"]["stage"]
-  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(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
-
-  if old_stage != new_stage
-    bridge_data["observe"]["last_transition"] = "#{old_stage} → #{new_stage}"
-  end
-
-  Bridge.write(session, bridge_data)
-
-  # Build transition context — ONE concise sentence (intent 84, Lever 1),
-  # preserving the `Next: ...` hint. Formatting is pure in Bridge.gate_narration.
-  context = Bridge.gate_narration(
-    old_stage: old_stage, new_stage: new_stage,
-    basename: basename, new_missing: new_missing
-  )
-
-  payload = {
-    "hookSpecificOutput" => {
-      "hookEventName" => "PostToolUse",
-      "additionalContext" => context
-    }
-  }
-  puts JSON.generate(payload)
-  exit 0
-else
-  # 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
-end

package/scripts/hook-links-gate

@@ -1,54 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-# frozen_string_literal: true
-
-# PreToolUse links gate (intent 192): denies an Edit/Write whose payload
-# changes a REAL ## Links section to anything other than exactly what
-# LinksProjection would emit for the file's own frontmatter. This is the
-# write-time belt for the PLASTIC.md ## Links contract; scripts/project-links
-# is the safe-repair path this gate always leaves open (it runs via Bash, a
-# tool this gate does not intercept).
-#
-# Reads the PreToolUse payload as JSON on STDIN:
-#   { "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/edit_gates"
-
-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)
-
-  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
-  # here so a gate bug (an unreadable UNRELATED store dir, a resolver crash, or
-  # anything else) never bricks editing; mirrors hook-lock-gate's own top-level
-  # rescue (ruling: the gate must fail open, never closed, on a computation it
-  # cannot complete).
-  $stderr.puts "plastic links-gate error: #{e.message}"
-  exit 0
-end

package/scripts/hook-lock-gate

@@ -1,47 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-# frozen_string_literal: true
-#
-# Usage: hook-lock-gate <file_path> [session_id] [harness]
-# Fail-CLOSED PreToolUse gate (intent 96). Blocks a mutating write to an active
-# intent's lifecycle dir when THIS session holds no live lock. Project code is NOT
-# 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.
-#
-# 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]
-  exit 0 unless file_path && !file_path.empty?
-  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). 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"
-
-  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
-  # here so a gate bug never bricks editing; the fail-CLOSED intent is about MISSING
-  # locks, not crashes.
-  $stderr.puts "plastic lock-gate error: #{e.message}"
-  exit 0
-end

package/scripts/hook-power-tools

@@ -1,38 +0,0 @@
-#!/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

@@ -1,32 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-# frozen_string_literal: true
-# Usage: hook-savepoint-pre <file_path>
-#
-# PreToolUse savepoint trigger (intent 81). When a stage-opening lifecycle file
-# (spec.md => Why, plan.md => How) is ABOUT to be written into an intent dir,
-# append the pre-stage `started` ledger line so the ledger records "this stage
-# was entered" before its artifact lands.
-#
-# Like the PostToolUse decoupled savepoint write (intent 52), it is derived from
-# the file path alone: no bridge, no session, fires headless. It NEVER blocks a
-# 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/edit_gates"
-
-file_path = ARGV[0]
-exit 0 if file_path.nil? || file_path.empty?
-
-EditGates.savepoint_pre(
-  EditGates::Context.new(tool_name: "Write", file_path: file_path, harness: "claude")
-)
-exit 0

package/scripts/lib/codex_edit_gates.rb

@@ -1,138 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-# CodexEditGates (intent 251): the merged Codex apply_patch edit path. One
-# process, one stdin parse, one envelope parse, five gates in-process.
-#
-# Before this, ~/.codex/hooks.json registered five separate PreToolUse commands
-# on the apply_patch matcher and three of them spawned a further run_core child
-# per file operation: eight processes per edit, ten across a full edit cycle.
-# This is the Codex mirror of what intent 244 did for Claude (spec D-e of that
-# intent parked it as a successor).
-#
-# Every DECISION here comes from scripts/lib/edit_gates.rb, the same functions
-# scripts/hook-edit-gates drives for Claude. This file contributes exactly three
-# Codex-specific things and nothing else:
-#   1. the per-operation Context (the patch envelope carries a path plus ADDED
-#      lines, not Claude's file_path plus content pair),
-#   2. the add-only rule for create-gate (Update/Delete/Move defer to the
-#      PostToolUse gate-check backstop, intent 102 spec Decision 5), and
-#   3. the two-pass evaluation that keeps savepoint-pre's ledger append
-#      unconditional across a multi-operation patch (intent 244 spec D-c).
-#
-# NO SUBPROCESS MAY EVER BE ADDED TO THIS FILE. That is the whole point of the
-# intent, and test/codex_edit_gates_test.rb asserts it against this source.
-require "stringio"
-require_relative "edit_gates"
-require_relative "hook_registry"
-
-module CodexEditGates
-  module_function
-
-  # Pass 1 and pass 2 of the two-pass evaluation (spec D3). Both slices preserve
-  # HookRegistry::CODEX_GATE_TOOLS key order, which is Claude's evaluation order
-  # (spec D5): savepoint-pre, lock-gate, code-gate, links-gate, create-gate.
-  SAVEPOINT_TOOLS = HookRegistry::CODEX_GATE_TOOLS.select { |gate, _| gate == "savepoint-pre" }.freeze
-  DENY_TOOLS      = HookRegistry::CODEX_GATE_TOOLS.reject { |gate, _| gate == "savepoint-pre" }.freeze
-
-  # One Context per file operation. gate_path and file_path both carry the
-  # envelope's raw path, exactly as the five popened cores received it in ARGV[0]
-  # before the merge. content is always a String (never nil), because
-  # ApplyPatchEnvelope gives a Delete op a nil added_content and today's
-  # dispatcher already called .to_s on it at every call site. harness is "codex"
-  # so lock-gate and the claim gate render deny reasons in the $plastic-<name>
-  # form (intent 201 D2).
-  def context_for(payload, op, env: ENV)
-    session = payload["session_id"]
-    session = env["CLAUDE_CODE_SESSION_ID"] if session.to_s.empty?
-
-    EditGates::Context.new(
-      tool_name: payload["tool_name"],
-      session: (session unless session.to_s.empty?),
-      gate_path: op.path,
-      file_path: op.path,
-      savepoint_path: op.path,
-      content: op.added_content.to_s,
-      harness: "codex",
-    )
-  end
-
-  # create-gate is a pre-write veto for ADD operations only (spec D2).
-  # EditGates.create_gate has no such rule: fed a partial Update hunk as content
-  # it would run IntentValidator on a fragment and FALSE-DENY a legitimate write.
-  def create_gate(ctx, op)
-    return EditGates::ALLOW unless op.op == :add
-    EditGates.create_gate(ctx)
-  end
-
-  def route_for(op)
-    lambda do |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 create_gate(ctx, op)
-      end
-    end
-  end
-
-  # True iff tool_name is a NON-EMPTY string that no CODEX_GATE_TOOLS entry
-  # matches. An empty/missing tool_name already means "the harness matched but
-  # did not name the tool" and every gate runs (EditGates.tool_applies?'s own
-  # empty-name rule); this is the OTHER unmatched case, a non-empty tool_name
-  # this dispatcher does not recognize. Checked once against "apply_patch",
-  # since every CODEX_GATE_TOOLS value is the identical single-entry list.
-  def unexpected_tool_name?(tool_name)
-    return false if tool_name.to_s.empty?
-    !EditGates.tool_applies?(tool_name, %w[apply_patch])
-  end
-
-  # Returns the process exit code. Two passes (spec D3):
-  #   pass 1 runs savepoint-pre over EVERY op. It never denies, and running it
-  #   before any deny check keeps its started ledger append unconditional, so
-  #   op B's ledger line still lands when op A is blocked.
-  #   pass 2 runs the four denying gates per op, first deny wins.
-  # EditGates.dispatch returns 0 both for "allowed" and for lock-gate's JSON
-  # deny, so pass 2 captures stdout per op: a non-empty buffer IS a deny, and it
-  # is printed and evaluation stops. Without that capture a second op could emit
-  # a second deny JSON.
-  #
-  # Codex only ever invokes this dispatcher from the apply_patch matcher, so by
-  # the time we get here the harness HAS already matched, regardless of what
-  # tool_name the payload itself carries. A non-empty, unrecognized tool_name
-  # (a future Codex rename, or a malformed/adversarial payload) must therefore
-  # never silently skip every gate: that is the coverage WEAKENING
-  # EditGates.tool_applies?'s own empty-name rule exists to prevent, just
-  # triggered from the opposite direction (an unrecognized name here, not a
-  # missing one there). Loud and safe: warn once to err and run all five gates
-  # exactly as if tool_name had been "apply_patch", rather than silent and
-  # permissive.
-  def dispatch(ops:, payload:, out: $stdout, err: $stderr)
-    if unexpected_tool_name?(payload["tool_name"])
-      err.puts "plastic codex edit-gates: unexpected tool_name #{payload["tool_name"].inspect}; " \
-                "the apply_patch matcher already selected this dispatcher, so all five gates run anyway"
-      payload = payload.merge("tool_name" => "apply_patch")
-    end
-
-    pairs = ops.map { |op| [op, context_for(payload, op)] }
-
-    pairs.each do |op, ctx|
-      EditGates.dispatch(ctx: ctx, route: route_for(op), gate_tools: SAVEPOINT_TOOLS,
-                         out: StringIO.new, err: err)
-    end
-
-    pairs.each do |op, ctx|
-      buffer = StringIO.new
-      code = EditGates.dispatch(ctx: ctx, route: route_for(op), gate_tools: DENY_TOOLS,
-                                out: buffer, err: err)
-      return code unless code.zero?
-      next if buffer.string.empty?
-
-      out.print buffer.string
-      return 0
-    end
-
-    0
-  end
-end