@zalom/plastic 1.14.1 → 2.0.0-alpha.2

package/scripts/lib/exec_worktree.rb

@@ -3,12 +3,13 @@
 
 require "open3"
 require_relative "bridge"
+require_relative "arm"
 require_relative "lock"
 require_relative "worktree"
 require_relative "scaffold_intent"
 
 # ExecWorktree - all logic for `scripts/exec-worktree` (intent 213, group 2). Finish an
-# intent's code worktree: an order precondition, then `Worktree.finish` (delivered merges
+# intent's code worktree: the dirty-worktree guard, then `Worktree.finish` (delivered merges
 # and removes, abandoned removes only).
 #
 # THIS IS THE HIGHEST-RISK SURFACE IN THIS ACTION SET because it composes worktree
@@ -21,22 +22,13 @@ require_relative "scaffold_intent"
 # either of the Lock module's release or takeover operations (that unguarded
 # read-modify-write gap is parked intent 254's territory).
 #
-# THE ORDER-PRECONDITION TRAP (spec D7, binding). `Bridge.code_gate_decision` returns nil
-# UNCONDITIONALLY when the bridge is guided (`build["auto"] != true`), so as a precondition
-# it is VACUOUS in guided mode. This module calls that predicate exactly as it exists,
-# unmodified, and never copies its "reached How" body into a second predicate (the 200/204
-# duplication failure pattern). Instead it states plainly, in the printed output, that on a
-# guided bridge the precondition is advisory only, and that the hook layer
-# (`Bridge.code_gate_decision`, wired through `scripts/lib/edit_gates.rb`) remains the
-# actual enforcement point.
-#
 # Pure and dependency-injected: never calls `exit` or `abort`, never reads `ARGV` directly.
 # Seams: `runner:` (git, defaults to `Worktree::ShellRunner.new`; also used AFTER finish, for
 # a delivered disposition, to verify from committed git state that the merge actually landed,
 # since `Worktree.finish`'s return value is discarded by design and its underlying merge is
 # fail-open, see the merge-verification note below), `finisher:` (defaults to
 # `Worktree.method(:finish)`), `status_checker:` (defaults to a `git status --porcelain`
-# lambda), `gate:` (defaults to `Bridge.method(:code_gate_decision)`). Every seam exists so
+# lambda). Every seam exists so
 # tests run with no real git, no real worktree removal, and no real bridge file outside a
 # tmpdir.
 #
@@ -58,21 +50,10 @@ module ExecWorktree
 
   EXIT_OK = 0
   EXIT_USAGE = 1
-  EXIT_PRECONDITION = 2
+  # exit 2 was the order precondition; retired in 2.0 (intent 302) and never reused
   EXIT_NOT_CLEAN = 3
   EXIT_UNRESOLVED = 4
 
-  PROBE_FILENAME = "exec-worktree-precondition-probe"
-
-  # The advisory line, verbatim (spec D7): printed whenever the order precondition
-  # actually ran (delivered disposition, a code worktree present), on BOTH the pass and
-  # the fail path, so no reader mistakes this script for the enforcement point.
-  ADVISORY_LINE =
-    "This precondition is a friendly early error, not the enforcement point. The hook " \
-    "layer (scripts/lib/bridge.rb code_gate_decision, wired through " \
-    "scripts/lib/edit_gates.rb) remains the actual gate. On a guided bridge this " \
-    "precondition is advisory only."
-
   # --- seams (DI defaults) ----------------------------------------------------------
 
   # Real `git status --porcelain` against the code worktree, returning the same
@@ -119,8 +100,7 @@ module ExecWorktree
     false
   end
 
-  # Session resolution order (mirrors scripts/end-intent:418-426, not
-  # scripts/start-intent's no-fallback order): explicit --session, else
+  # Session resolution order (mirrors scripts/end-intent:418-426): explicit --session, else
   # CLAUDE_CODE_SESSION_ID (passed in as env_session, never read from ENV here), else
   # the existing delivery.lock's own recorded owner_session when non-blank, else nil.
   # The lock-owner fallback is correct here: this is a teardown step on an intent this
@@ -134,7 +114,7 @@ module ExecWorktree
     Bridge.blank?(owner) ? nil : owner
   end
 
-  # --- result builders (mirror StartIntent's exit_code/stdout/stderr shape) --------
+  # --- result builders (the exit_code/stdout/stderr shape the thin CLIs share) --------
 
   def usage_result(message)
     { exit_code: EXIT_USAGE, stderr: ["exec-worktree: #{message}"], stdout: [] }
@@ -156,15 +136,9 @@ module ExecWorktree
       "recorded owner are all blank); refusing rather than guessing."
   end
 
-  def no_bridge_message(intent_dir, session, id)
-    "exec-worktree: no bridge resolved for session #{session.inspect} and intent " \
-      "#{id.inspect} (#{File.basename(intent_dir)}); any worktree this intent provisioned " \
-      "was NOT removed. Run /plastic-doctor to check for an orphaned worktree."
-  end
-
   def nothing_provisioned_message(intent_dir)
-    "exec-worktree: #{File.basename(intent_dir)} has no code worktree recorded on its " \
-      "bridge (precondition: skipped, no code worktree); nothing was provisioned, nothing " \
+    "exec-worktree: #{File.basename(intent_dir)} has no code worktree on disk " \
+      "(projects.yml and the intent id resolve none); nothing was provisioned, nothing " \
       "to finish."
   end
 
@@ -195,7 +169,7 @@ module ExecWorktree
 
   # --- report (printed only when the run reaches a normal finish) ------------------
 
-  def build_report(intent_dir:, disposition:, precondition_status:, worktree_code:, branch:,
+  def build_report(intent_dir:, disposition:, worktree_code:, branch:,
                    target_branch:, removed:)
     # This is only ever reached for "delivered" AFTER `run` has already confirmed, by
     # reading committed git state (merged_into_current_branch?), that `branch` IS an
@@ -215,7 +189,6 @@ module ExecWorktree
     [
       "exec-worktree: #{File.basename(intent_dir)}",
       "  disposition: #{disposition}",
-      "  precondition: #{precondition_status}",
       "  worktree:     #{worktree_code}",
       "  branch:       #{branch}",
       "  merge:        #{merge_line}",
@@ -228,8 +201,7 @@ module ExecWorktree
   def run(store:, id:, home:, disposition:, session:, env_session:,
           runner: Worktree::ShellRunner.new,
           finisher: Worktree.method(:finish),
-          status_checker: default_status_checker,
-          gate: Bridge.method(:code_gate_decision))
+          status_checker: default_status_checker)
     return usage_result("--store is required") if Bridge.blank?(store)
     return usage_result("--id is required") if Bridge.blank?(id)
     return usage_result("--home is required") if Bridge.blank?(home)
@@ -252,9 +224,7 @@ module ExecWorktree
       return deny_result(EXIT_UNRESOLVED, no_session_message(intent_dir))
     end
 
-    bridge_data = Bridge.blank?(key_session) ? nil : Bridge.read(key_session, intent_id: id)
-    return ok_result(no_bridge_message(intent_dir, key_session, id)) if bridge_data.nil?
-
+    bridge_data = Arm.bridge_hash(intent_dir: intent_dir, home: normalized_home)
     worktree_code = bridge_data.dig("worktree", "code")
     return ok_result(nothing_provisioned_message(intent_dir)) if Bridge.blank?(worktree_code)
 
@@ -264,22 +234,8 @@ module ExecWorktree
     # both `repo` and `branch` to work with.
     repo = repo_from_worktree_code(worktree_code)
 
-    precondition_ran = false
-    precondition_status = "not run (abandoned)"
-
     if disposition == "delivered"
-      precondition_ran = true
-
-      # Step 1: the order precondition. Call Bridge.code_gate_decision AS-IS (never
-      # relaxed, never duplicated). See the module doc's "order-precondition trap".
-      probe_path = File.join(worktree_code, PROBE_FILENAME)
-      reason = gate.call(bridge_data, probe_path, home: normalized_home)
-      if reason
-        return deny_result(EXIT_PRECONDITION, [reason, ADVISORY_LINE])
-      end
-      precondition_status = bridge_data.dig("build", "auto") == true ? "passed" : "advisory (guided bridge)"
-
-      # Step 2: the dirty-worktree guard, delivered only. Fail CLOSED when the check
+      # Step 1: the dirty-worktree guard, delivered only. Fail CLOSED when the check
       # itself fails or raises: removal force-removes on a plain failure, which would
       # destroy uncommitted work an inconclusive check could not rule out.
       out, err, status = status_checker.call(worktree_code)
@@ -290,7 +246,7 @@ module ExecWorktree
       end
     end
 
-    # Step 3: finish. Worktree.finish is fail-open and never raises: on a merge conflict it
+    # Step 2: finish. Worktree.finish is fail-open and never raises: on a merge conflict it
     # aborts the merge, warns, and STILL removes the worktree (Worktree.merge_branch,
     # scripts/lib/worktree.rb:246-258). So a failed merge is invisible both in this call's
     # return value (discarded, as before) and in whether the worktree directory still
@@ -315,11 +271,9 @@ module ExecWorktree
     end
 
     report = build_report(intent_dir: intent_dir, disposition: disposition,
-                          precondition_status: precondition_status,
                           worktree_code: worktree_code, branch: branch,
                           target_branch: target_branch, removed: removed)
 
-    stdout = precondition_ran ? [ADVISORY_LINE, report] : [report]
-    ok_result(stdout)
+    ok_result([report])
   end
 end

package/scripts/lib/handoff.rb

@@ -0,0 +1,184 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Handoff (intent 311): one session's hand-off, a pure rendering of its share
+# of a day ledger (checklist.md and savepoint.md), written into the day
+# directory as handoff--<session>.md at every tick, at PreCompact, and at
+# close. Derived and regenerable: every write renders in full, so a lost or
+# stale copy costs nothing. No environment reads; every path is injected.
+
+require "fileutils"
+require_relative "session_ledger"
+
+module Handoff
+  module_function
+
+  TRIGGERS = %w[tick precompact close].freeze
+  BUDGET = 6144
+  OPEN_CAP = 20
+  DONE_CAP = 10
+  RECENT_CAP = 10
+  OTHERS_CAP = 10
+  # A ledger summary may run to 200 characters; a hand-off line shows the
+  # first 80, so the caps above are reachable inside the byte budget.
+  SUMMARY_MAX = 80
+  OPEN_STATES = %i[open pending].freeze
+  # Trimmed first when the budget is exceeded; Open is the last to shrink.
+  TRIM_ORDER = %i[others recent done open].freeze
+  RESUME = "Say continue; the day summary at boot and this file carry the state."
+
+  SAVEPOINT_TAIL_RE = /\A\[([^\]]*)\] \[([^\]]*)\] (.*)\z/m
+  private_constant :SAVEPOINT_TAIL_RE
+
+  def path_for(store, day, session)
+    File.join(SessionLedger.day_dir(store, day), "handoff--#{session}.md")
+  end
+
+  # The day this session's hand-off belongs to: the pointer's day id when
+  # the pointer holds one, else today (no pointer, or a pointer naming an
+  # intent), the same fallback SessionClose uses for the drop at close.
+  def day_for(store, session, today:)
+    path = SessionLedger.pointer_path(store, session)
+    return today unless File.exist?(path)
+
+    value = File.read(path).strip
+    SessionLedger.valid_day_id?(value) ? value : today
+  end
+
+  def clip(summary)
+    text = summary.to_s
+    text.length > SUMMARY_MAX ? "#{text[0, SUMMARY_MAX]}..." : text
+  end
+
+  # --- readers ---------------------------------------------------------------------
+
+  def read_items(store, day)
+    SessionLedger.read_locked(SessionLedger.checklist_path(store, day))
+                 .each_line.filter_map { |l| SessionLedger.parse_checklist_line(l) }
+  end
+
+  # Parsed savepoint lines, file order: {time:, event:, session:, project:,
+  # summary:}. A line that does not follow the ledger grammar is skipped.
+  def read_savepoint(store, day)
+    SessionLedger.read_locked(SessionLedger.savepoint_path(store, day)).each_line.filter_map do |raw|
+      line = raw.chomp.scrub
+      next if line.empty?
+
+      time, event, rest = line.split(/\s{2,}/, 3)
+      next unless time && event && rest
+
+      match = SAVEPOINT_TAIL_RE.match(rest)
+      next unless match
+
+      { time: time, event: event, session: match[1], project: match[2], summary: match[3] }
+    end
+  end
+
+  # --- rendering, pure -----------------------------------------------------------
+
+  def render(store:, day:, session:, trigger:, now: Time.now)
+    raise ArgumentError, "unknown trigger: #{trigger.inspect}" unless TRIGGERS.include?(trigger)
+
+    items = read_items(store, day)
+    mine = items.select { |i| i[:session] == session }
+    lists = {
+      open: mine.select { |i| OPEN_STATES.include?(i[:state]) }.map { |i| item_line(i) },
+      done: mine.select { |i| i[:state] == :done }.map { |i| item_line(i) },
+      recent: read_savepoint(store, day).select { |e| e[:session] == session }.map { |e| recent_line(e) },
+      others: others_lines(items, session),
+    }
+    hidden = Hash.new(0)
+    cap!(lists, hidden, :open, OPEN_CAP)
+    cap!(lists, hidden, :done, DONE_CAP)
+    cap!(lists, hidden, :recent, RECENT_CAP)
+    if lists[:others].size > OTHERS_CAP
+      hidden[:others] += lists[:others].size - OTHERS_CAP
+      lists[:others] = lists[:others].first(OTHERS_CAP)
+    end
+
+    header = [
+      "# Hand-off: session #{session}, #{day}",
+      "",
+      "Written #{now.utc.strftime('%Y-%m-%dT%H:%M:%SZ')} at #{trigger}",
+      "",
+    ]
+    loop do
+      text = compose(header, lists, hidden)
+      return text if text.bytesize <= BUDGET
+
+      key = TRIM_ORDER.find { |k| !lists[k].empty? }
+      return text unless key
+
+      # Open, Done, and Recent keep their newest entries; Others has no order.
+      key == :others ? lists[key].pop : lists[key].shift
+      hidden[key] += 1
+    end
+  end
+
+  # Keeps the newest `cap` lines (the file is chronological) and counts the rest.
+  def cap!(lists, hidden, key, cap)
+    return unless lists[key].size > cap
+
+    hidden[key] += lists[key].size - cap
+    lists[key] = lists[key].last(cap)
+  end
+
+  def compose(header, lists, hidden)
+    sections = [
+      section("Open", lists[:open], hidden[:open]),
+      section("Done", lists[:done], hidden[:done]),
+      section("Recent", lists[:recent], hidden[:recent]),
+      section("Others today", lists[:others], hidden[:others]),
+      "## Resume\n#{RESUME}\n",
+    ]
+    (header + sections.compact).join("\n")
+  end
+
+  def section(title, lines, hidden)
+    return nil if lines.empty? && hidden.zero?
+
+    body = lines.dup
+    body << "(+#{hidden} more)" if hidden.positive?
+    "## #{title}\n#{body.join("\n")}\n"
+  end
+
+  def item_line(item)
+    "- [#{item[:project]}] #{clip(item[:summary])}"
+  end
+
+  def recent_line(event)
+    "- #{event[:time][11, 5]}Z #{event[:event]} #{clip(event[:summary])}"
+  end
+
+  def others_lines(items, session)
+    items.reject { |i| i[:session] == session }
+         .group_by { |i| i[:session] }
+         .sort
+         .map do |sid, theirs|
+      open = theirs.count { |i| OPEN_STATES.include?(i[:state]) }
+      done = theirs.count { |i| i[:state] == :done }
+      "- #{sid}: #{open} open, #{done} done"
+    end
+  end
+
+  # --- writing -------------------------------------------------------------------
+
+  # Opens the day first (a tick after midnight never fails), renders, and
+  # writes through a per-process temp file and rename, so a crash leaves no
+  # partial hand-off and two writers for one session (a tick overlapping a
+  # PreCompact) never share a temp name. Returns the path. With
+  # `templates: nil` the day is not scaffolded, only its directory ensured.
+  def write(store:, day:, session:, trigger:, templates:, now: Time.now)
+    if templates
+      SessionLedger.open_day(store: store, day: day, templates: templates, author: session)
+    else
+      FileUtils.mkdir_p(SessionLedger.day_dir(store, day))
+    end
+    text = render(store: store, day: day, session: session, trigger: trigger, now: now)
+    target = path_for(store, day, session)
+    tmp = File.join(File.dirname(target), ".handoff-#{session}-#{Process.pid}-#{Thread.current.object_id}.tmp")
+    File.write(tmp, text)
+    File.rename(tmp, target)
+    target
+  end
+end

package/scripts/lib/harness_text.rb

@@ -19,9 +19,10 @@ module HarnessText
   # form the install_claude hook rewrite already writes.
   PLUGIN_ROOT_CODEX = "$HOME/.plastic"
 
-  # Spec D3: these files document Claude's placeholder convention TO SKILL AUTHORS.
-  # Rewriting the token there turns true sentences false, so the file is exempt by path.
-  PLUGIN_ROOT_EXEMPT = ["skill-creating/references/hooks.md"].freeze
+  # Spec D3: files that document Claude's placeholder convention TO SKILL AUTHORS are
+  # exempt by path. The skill-authoring reference left the installed tree in 2.0
+  # (intent 304), so the list is empty; the seam stays for the next such file.
+  PLUGIN_ROOT_EXEMPT = [].freeze
 
   # Spec D4: an explicit root table, not one regex. The ~/.claude lines in the skill
   # corpus carry four different meanings; only these three have an exact Codex
@@ -46,7 +47,7 @@ module HarnessText
   #   "~/.claude/hooks/plastic-session-start");
   #   the name alternation, built from the real skills/ directory listing, rejects
   #   anything that is not an installed skill ("/plastic-lock" is a CLI script,
-  #   "/plastic-intent-curator" is an agent role).
+  #   "/plastic-enforcer" is an agent role).
   # Longest name first so /plastic-intent-continuing cannot match "continuing".
   def rewrite_skill_prefix(text, skill_names, prefix)
     return text if skill_names.nil? || skill_names.empty?

package/scripts/lib/hook_registry.rb

@@ -10,9 +10,8 @@
 module HookRegistry
   module_function
 
-  # MCP tools that MUTATE files. Every write/lock/create gate must match them,
-  # or symbolic edits bypass the whole gate layer (the universal MCP-edit
-  # bypass found in 108's gate inventory).
+  # MCP tools that MUTATE files. The record hook must match them, or a symbolic
+  # edit never reaches the savepoint ledger or the day ledger.
   SERENA_EDIT_TOOLS = %w[
     mcp__serena__replace_content
     mcp__serena__replace_symbol_body
@@ -24,40 +23,6 @@ module HookRegistry
 
   WRITE_MATCHER = (%w[Write Edit NotebookEdit] + SERENA_EDIT_TOOLS).join("|")
 
-  # Per-gate tool applicability for the merged edit-path dispatcher (intent 244,
-  # spec D-d/D-l). Registration collapses to ONE PreToolUse hook on WRITE_MATCHER
-  # (a strict superset of the three former matcher groups), and this table is what
-  # keeps each gate's own coverage exactly what it was: scripts/hook-edit-gates
-  # reads tool_name off the payload and skips any gate whose list excludes it.
-  # Key order IS the evaluation order (spec D-a): savepoint-pre first because it
-  # never denies and its ledger append must stay unconditional; lock-gate leads
-  # the deniers because holding the delivery lock is the precondition the other
-  # rules assume. A test pins this table against today's three matcher groups, so
-  # no gate's coverage can widen or narrow silently.
-  GATE_TOOLS = {
-    "savepoint-pre" => %w[Write Edit].freeze,
-    "lock-gate"     => (%w[Write Edit NotebookEdit] + SERENA_EDIT_TOOLS).freeze,
-    "code-gate"     => (%w[Write Edit NotebookEdit] + SERENA_EDIT_TOOLS).freeze,
-    "links-gate"    => %w[Write Edit].freeze,
-    "create-gate"   => (%w[Write Edit] + SERENA_EDIT_TOOLS).freeze,
-  }.freeze
-
-  # Per-gate tool applicability for the merged CODEX edit-path dispatcher (intent
-  # 251, spec D1). Codex reports exactly one file-mutation tool name, apply_patch
-  # (intent 181 F4), so every value is the same single-entry list. The table is
-  # NOT decoration: EditGates.tool_applies? builds a regex from these values, and
-  # reusing GATE_TOOLS here would match none of them against "apply_patch" and
-  # silently skip all five gates. Key order IS the evaluation order and is the
-  # SAME order GATE_TOOLS uses (spec D5), so the two harnesses evaluate the five
-  # gates in one order, not two.
-  CODEX_GATE_TOOLS = {
-    "savepoint-pre" => %w[apply_patch].freeze,
-    "lock-gate"     => %w[apply_patch].freeze,
-    "code-gate"     => %w[apply_patch].freeze,
-    "links-gate"    => %w[apply_patch].freeze,
-    "create-gate"   => %w[apply_patch].freeze,
-  }.freeze
-
   # event => ordered list of { "matcher" =>, "hooks" => [{ "name" =>, "status" => }] }
   # The name is the hooks/<name> launcher; the flat install ships it as
   # ~/.claude/hooks/plastic-<name>.
@@ -74,75 +39,54 @@ module HookRegistry
           { "name" => "savepoint", "status" => "Saving Plastic intent state..." },
         ] },
       ],
-      "PreToolUse" => [
-        # ONE registered edit-path hook (intent 244, spec D-d). WRITE_MATCHER is a
-        # strict superset of the three matcher groups this replaces; per-gate tool
-        # applicability lives in GATE_TOOLS above and is read by
-        # scripts/hook-edit-gates, so no gate's coverage widened or narrowed.
+      "PostToolUse" => [
         { "matcher" => WRITE_MATCHER, "hooks" => [
-          { "name" => "edit-gates", "status" => "Checking Plastic gates..." },
-        ] },
-        { "matcher" => "Bash", "hooks" => [
-          { "name" => "bash-gate", "status" => "Checking lifecycle gate..." },
+          { "name" => "record", "status" => "Recording Plastic session state..." },
         ] },
       ],
-      "PostToolUse" => [
-        { "matcher" => "Write|Edit", "hooks" => [
-          { "name" => "gate-check", "status" => "Checking lifecycle gates..." },
+      "SessionEnd" => [
+        { "matcher" => "", "hooks" => [
+          { "name" => "close", "status" => "Closing the Plastic session..." },
         ] },
       ],
       "UserPromptSubmit" => [
         { "matcher" => "", "hooks" => [
-          { "name" => "continue", "status" => "Checking for continue..." },
-          { "name" => "future-intent-check", "status" => "Checking future intents..." },
-          { "name" => "auto-arm", "status" => "Checking auto mode..." },
-          { "name" => "power-tools", "status" => "Checking power tools..." },
+          { "name" => "capture", "status" => "Capturing prompt into the session ledger..." },
         ] },
       ],
     }
   end
 
   # Codex registration (~/.codex/hooks.json, intent 102). Derived from `events`:
-  # the file-mutation PreToolUse gate/savepoint hooks collapse from Claude's
-  # multi-tool matchers onto Codex's single apply_patch tool (181 F4: apply_patch
-  # is Codex's sole file-mutation tool; tool_name always reports apply_patch), plus
-  # the PostToolUse gate-check. Command invokes the codex-hook dispatcher with the
-  # gate name. Guide-settled shape [guide Part 3]: top-level {"hooks":{<Event>:
-  # [{"matcher","hooks":[{"type":"command","command","statusMessage"}]}]}},
-  # identical to Claude's shape, string command. Single source of truth (108 D7):
-  # any drift from `events` is a bug, pinned by test.
-  #
-  # Codex's apply_patch matcher carries ONE dispatcher command, edit-gates,
-  # which runs all five gates in-process through scripts/lib/codex_edit_gates.rb
-  # (intent 251), mirroring what intent 244 did for Claude. Five separately
-  # registered commands used to cost eight OS processes per edit (five
-  # top-level plus three nested run_core children); one dispatcher process
-  # reaches the same five gate decisions.
-  CODEX_PRE_HOOKS  = %w[edit-gates].freeze
-  CODEX_POST_HOOKS = %w[gate-check].freeze
-
-  # Codex's shell-tool gate hole (intent 203): bash-gate (denies a shell write to
-  # project code before How) belongs on the Bash matcher, and ONLY Bash: the
-  # official Codex hooks doc's PreToolUse event catalog enumerates exactly Bash,
-  # apply_patch, and MCP tool calls, and neither it nor the two prior Codex
-  # research passes (198's official-docs research, 181's deep research)
-  # documents a discrete Read, Grep, or Glob tool name (D3). Registering a tool
-  # name Codex never reports would be dead weight that looks alive, the exact
-  # defect this intent exists to fix.
-  CODEX_BASH_HOOKS = %w[bash-gate].freeze
-
-  # Live-state events registered WHOLE (intent 199), unlike CODEX_PRE_HOOKS/
-  # CODEX_POST_HOOKS above: Codex's SessionStart/UserPromptSubmit/PreCompact already
-  # match Claude's shape exactly, one matcher group each ("", no tool to collapse
-  # onto), so every hook `events` lists under these three events projects straight
-  # through with no allowlist to keep in sync. A hook added to any of them on the
-  # Claude side registers for Codex automatically.
+  # the PostToolUse record hook collapses from Claude's multi-tool matcher onto
+  # Codex's single apply_patch tool (181 F4: apply_patch is Codex's sole
+  # file-mutation tool; tool_name always reports apply_patch), and the live-state
+  # events project through whole. Since intent 302 there is no PreToolUse group at
+  # all: the edit-path gates are gone on both harnesses. Command invokes the
+  # codex-hook dispatcher with the hook name. Guide-settled shape [guide Part 3]:
+  # top-level {"hooks":{<Event>: [{"matcher","hooks":[{"type":"command","command",
+  # "statusMessage"}]}]}}, identical to Claude's shape, string command. Single
+  # source of truth (108 D7): any drift from `events` is a bug, pinned by test.
+  CODEX_POST_HOOKS = %w[record].freeze
+
+  # Live-state events registered WHOLE (intent 199): Codex's SessionStart/
+  # UserPromptSubmit/PreCompact already match Claude's shape exactly, one matcher
+  # group each ("", no tool to collapse onto), so every hook `events` lists under
+  # these three events projects straight through with no allowlist to keep in
+  # sync. A hook added to any of them on the Claude side registers for Codex
+  # automatically.
   CODEX_LIVE_STATE_EVENTS = %w[SessionStart UserPromptSubmit PreCompact].freeze
 
+  # SessionEnd on Codex (intent 309): projected from its own constant, never as a fourth
+  # live-state event, because the dispatch differs. Codex kills a SessionEnd hook after
+  # 3 seconds, so scripts/codex-hook hands `close` to its launcher detached and returns at
+  # once instead of the synchronous relay the live-state hooks get. Codex ships both Stop
+  # and SessionEnd (codex-rs/hooks at rust-v0.149.1); the design uses SessionEnd on both
+  # harnesses. Like STATE_HOOKS, the dispatcher's list is hand-kept and cross-checked by
+  # test/hook_registry_test.rb.
+  CODEX_SESSION_END_HOOKS = %w[close].freeze
+
   def codex_hooks_json(dispatcher_path:)
-    # Every Codex hook name is now a name `events` itself carries (intent 251,
-    # spec D9): edit-gates is Claude's own PreToolUse hook name, so there is
-    # nothing left to merge in from a separate status table.
     status_by_name = events.values.flatten.flat_map { |g| g["hooks"] }
                            .each_with_object({}) { |h, m| m[h["name"]] = h["status"] }
     cmd = ->(name) {
@@ -150,27 +94,19 @@ module HookRegistry
         "command" => "\"#{dispatcher_path}\" #{name}",
         "statusMessage" => status_by_name[name].to_s }
     }
-    # Preserve the order these hook names appear across the PreToolUse groups in `events`.
-    pre_order = events["PreToolUse"].flat_map { |g| g["hooks"].map { |h| h["name"] } }
-    # The Codex apply_patch matcher carries the same edit-gates name Claude's own
-    # PreToolUse group carries (intent 251, spec D9), so the intersection with
-    # pre_order validates the Codex gate name against the single source of truth,
-    # `events`, rather than against a table of Claude tool applicability.
-    pre = (CODEX_PRE_HOOKS & pre_order).map { |n| cmd.call(n) }
-    bash = (pre_order & CODEX_BASH_HOOKS).map { |n| cmd.call(n) }
-    post = CODEX_POST_HOOKS.map { |n| cmd.call(n) }
+    # Validate the Codex name against the single source of truth, `events`.
+    post_order = events["PostToolUse"].flat_map { |g| g["hooks"].map { |h| h["name"] } }
+    post = (CODEX_POST_HOOKS & post_order).map { |n| cmd.call(n) }
 
     result = {
-      "PreToolUse"  => [
-        { "matcher" => "apply_patch", "hooks" => pre },
-        { "matcher" => "Bash", "hooks" => bash },
-      ],
       "PostToolUse" => [{ "matcher" => "apply_patch", "hooks" => post }],
     }
     CODEX_LIVE_STATE_EVENTS.each do |event|
       names = events[event].flat_map { |g| g["hooks"].map { |h| h["name"] } }
       result[event] = [{ "matcher" => "", "hooks" => names.map { |n| cmd.call(n) } }]
     end
+    end_order = events["SessionEnd"].flat_map { |g| g["hooks"].map { |h| h["name"] } }
+    result["SessionEnd"] = [{ "matcher" => "", "hooks" => (CODEX_SESSION_END_HOOKS & end_order).map { |n| cmd.call(n) } }]
     result
   end
 
@@ -179,8 +115,7 @@ module HookRegistry
   # installed as ~/.claude/hooks/plastic-<name>. The single derivation doctor's
   # hooks_exist/hooks_executable/hooks_no_orphans checks read from, so a
   # hand-kept list of launchers can never drift out of step with `events`
-  # again (the gap that let 8 of 15 launchers, all the enforcement gates, go
-  # unchecked).
+  # again (the gap that once let 8 of 15 launchers go unchecked).
   def claude_launcher_names
     events.values.flatten.flat_map { |g| g["hooks"].map { |h| h["name"] } }
           .uniq.sort.map { |name| "plastic-#{name}" }
@@ -204,8 +139,10 @@ module HookRegistry
   # hooks_exist demands be present on disk, so a retired name there makes a correct
   # install report missing launchers.
   RETIRED_HOOK_NAMES = %w[
-    code-gate create-gate links-gate lock-gate savepoint-pre
+    edit-gates bash-gate code-gate create-gate links-gate lock-gate savepoint-pre
     qmd-search retrieval-gate model-instructions opus-manual
+    continue future-intent-check auto-arm gate-check
+    power-tools
   ].freeze
 
   RETIRED_CLAUDE_LAUNCHERS = RETIRED_HOOK_NAMES.map { |n| "plastic-#{n}" }.freeze
@@ -226,7 +163,7 @@ module HookRegistry
     live = CODEX_LIVE_STATE_EVENTS.flat_map do |event|
       events[event].flat_map { |g| g["hooks"].map { |h| h["name"] } }
     end
-    (CODEX_PRE_HOOKS + CODEX_POST_HOOKS + CODEX_BASH_HOOKS + live).uniq.sort
+    (CODEX_POST_HOOKS + live + CODEX_SESSION_END_HOOKS).uniq.sort
   end
 
   def codex_purgeable_hook_names

package/scripts/lib/insights.rb

@@ -7,14 +7,13 @@
 #
 # Every entry leads with a fixed, machine-parseable prefix
 # `{utc-iso8601} · {stage} · {author}` where the timestamp is `now.utc.iso8601`,
-# the SAME convention `Bridge.append_savepoint_line` uses, so the store has one
+# the SAME convention `Savepoint.append_savepoint_line` uses, so the store has one
 # timestamp convention across both ledgers. Entries are append-only, newest at
 # the BOTTOM (the [[34]] ordering law): the per-entry prefix is not prepending
 # the entry, and existing entries are never reordered.
 
 require "time"
-require_relative "bridge"
-
+require_relative "savepoint"
 module Insights
   HEADING = "## Insights"
   # The middle dot (U+00B7) with a single space on each side separates the
@@ -35,7 +34,7 @@ module Insights
     end
 
     entry = "#{prefix} — #{text}"
-    path = Bridge.intent_file(intent_dir)
+    path = Savepoint.intent_file(intent_dir)
     File.write(path, with_entry(File.exist?(path) ? File.read(path) : "", entry))
     entry
   end