@zalom/plastic 1.0.3 → 1.1.1

package/scripts/doctor.rb

@@ -23,6 +23,8 @@ require_relative "lib/links_section"
 require_relative "lib/hook_registry"
 require_relative "lib/lock"
 require_relative "lib/bridge"
+require_relative "lib/agent_models"
+require_relative "lib/legacy_bookend_amnesty"
 
 # Diagnostic engine, instantiable with an injected store/agent map so tests can
 # run it hermetically (no eval, no global-constant rewriting).
@@ -41,6 +43,11 @@ class Doctor
   # (intent 60). Alias it here so the two can never drift.
   REQUIRED_FRONTMATTER_FIELDS = IntentValidator::REQUIRED_FIELDS
 
+  # Single source of truth for the pre-161 legacy Done-bookend amnesty list
+  # lives in LegacyBookendAmnesty (intent 170a). Alias it here so the two can
+  # never drift.
+  LEGACY_BOOKEND_AMNESTY = LegacyBookendAmnesty::LIST
+
   CLAUDE_HOOK_SCRIPTS = %w[
     plastic-session-start
     plastic-check-update
@@ -66,9 +73,11 @@ class Doctor
 
   attr_reader :plastic_home, :agents
 
-  def initialize(plastic_home: DEFAULT_PLASTIC_HOME, agents: DEFAULT_AGENTS)
+  def initialize(plastic_home: DEFAULT_PLASTIC_HOME, agents: DEFAULT_AGENTS,
+                  bookend_amnesty: LEGACY_BOOKEND_AMNESTY)
     @plastic_home = plastic_home
     @agents = agents
+    @bookend_amnesty = bookend_amnesty
   end
 
   # --- Flag parsing ---
@@ -476,7 +485,7 @@ class Doctor
         message: "#{bad_sections.size} intent file(s) have non-sanctioned ## sections",
         details: bad_sections.map { |b| "#{b[:dir]}: #{b[:issues].join(", ")}" },
         fixable: true,
-        fix_hint: "Dispatch plastic-intent-curator to relocate each unsanctioned section into the " \
+        fix_hint: "Dispatch plastic-store-curating to relocate each unsanctioned section into the " \
                   "intent's revisions.md via move-and-record (a missing required section is restored " \
                   "or reprojected instead); see PLASTIC.md > Structural maintenance and revisions.md"
       )
@@ -577,6 +586,7 @@ class Doctor
     conflicts = [] # canonical INDEX-wins disagreement (fail)
     gaps = []      # terminal completeness gaps on immutable/legacy history (warn)
     stalled = []   # terminal but End tail unfinished (warn)
+    phantoms = []  # savepoint.md line(s) disk evidence contradicts (warn, never fail; intent 134)
 
     done_signal_stores(scopes).each do |store|
       index_sections_by_dir(store[:index]).each do |dirname, in_sections|
@@ -596,6 +606,24 @@ class Doctor
                        "(INDEX is canonical — move it to its terminal section or revert outcome.md)"
         end
 
+        # Savepoint truthfulness (advisory, never fail; intent 134): a line the disk contradicts
+        # (a phantom milestone, a duplicate pair, or a state line with an absent prerequisite).
+        # Live intents auto-rebuild via plastic-intent-savepoint; terminal intents are immutable,
+        # so a phantom there is report-only. Composition with intent 170a: a pre-161 legacy intent
+        # on the frozen bookend amnesty is grandfathered here too. Its immutable history carries
+        # known pre-convention drift (the same class the audit-echo gap forgives), so it must not
+        # resurface through this advisory. The suppression is scope-qualified exactly like the
+        # audit-echo amnesty; every live intent and every non-amnestied terminal still fires.
+        phantom_lines = Bridge.savepoint_phantom_lines(dir)
+        phantom_id = dirname.split("--", 2).first
+        phantom_amnestied = terminal && @bookend_amnesty.fetch(store[:scope], []).include?(phantom_id)
+        if phantom_lines.any? && !phantom_amnestied
+          detail = phantom_lines.map { |line, reason| "#{line} (#{reason})" }.join("; ")
+          scope_note = terminal ? "terminal in INDEX, report-only (immutable history)" : "live intent, auto-rebuildable"
+          phantoms << "#{label}: #{phantom_lines.size} phantom savepoint line(s) contradicted by " \
+                      "disk, #{scope_note}: #{detail}"
+        end
+
         # Completeness gap (warn, not fail): a terminal intent whose outcome.md is
         # missing/placeholder. Legacy terminal intents predate this convention and
         # are immutable, so this is advisory, never breakage.
@@ -608,11 +636,18 @@ class Doctor
         next unless terminal
 
         # Audit echo (weakest signal, D1): the savepoint should carry a
-        # `Done delivered|abandoned` line. Missing on legacy history -> advisory gap.
+        # `Done delivered|abandoned` line. Missing on legacy history -> advisory
+        # gap, unless the (scope, id) is on the frozen pre-161 amnesty list
+        # (intent 170a). The amnesty is scope-qualified: an id on the list for
+        # one scope does not grandfather the same id in another scope.
         savepoint = File.join(dir, "savepoint.md")
         if File.exist?(savepoint) && File.read(savepoint) !~ /\bDone\b.*\b(delivered|abandoned)\b/
-          gaps << "#{label}: terminal in INDEX but savepoint.md has no " \
-                  "`Done delivered|abandoned` line (audit echo missing)"
+          id = dirname.split("--", 2).first
+          amnestied = @bookend_amnesty.fetch(store[:scope], []).include?(id)
+          unless amnestied
+            gaps << "#{label}: terminal in INDEX but savepoint.md has no " \
+                    "`Done delivered|abandoned` line (audit echo missing)"
+          end
         end
 
         # Stalled completion: the End tail never released the delivery lock, so the
@@ -660,7 +695,7 @@ class Doctor
                  "(outcome.md or the savepoint Done echo is missing; advisory on immutable history)",
         details: gaps, fixable: true,
         fix_hint: "For live terminals, author a real outcome.md with the `disposition:` header via the " \
-                  "completion/abandon path (plastic-auto or plastic-intent-curator) and stamp the terminal " \
+                  "completion/abandon path (plastic-auto or plastic-store-curating) and stamp the terminal " \
                   "savepoint. Legacy terminal intents are immutable, so pre-convention gaps stay advisory."
       )
     end
@@ -682,6 +717,26 @@ class Doctor
       )
     end
 
+    # savepoint_truthful: advisory only, never fails the run (intent 134). A phantom line on a
+    # live intent auto-rebuilds; on terminal (immutable) history it stays report-only.
+    if phantoms.empty?
+      checks << check(
+        category: "done_signals", name: "savepoint_truthful", status: "pass",
+        message: "No savepoint.md lines are contradicted by disk (phantom-line check clean)"
+      )
+    else
+      checks << check(
+        category: "done_signals", name: "savepoint_truthful", status: "warn",
+        message: "#{phantoms.size} intent#{phantoms.size == 1 ? "" : "s"} carry savepoint.md " \
+                 "line(s) contradicted by disk (advisory; terminal history stays report-only)",
+        details: phantoms, fixable: true,
+        fix_hint: "For a live (Active) intent, run plastic-intent-savepoint to rebuild via " \
+                  "Bridge.rebuild_savepoint. Terminal (Completed/Abandoned) intents are immutable: " \
+                  "a phantom there stays advisory unless an explicit human grant authorizes the " \
+                  "124a manual Done-bookend repair."
+      )
+    end
+
     checks
   end
 
@@ -882,7 +937,7 @@ class Doctor
     checks << graph_finding_check(
       "graph_i4_danglers", i4,
       "Every sources/chain id resolves to a real intent (I4)",
-      "Dispatch plastic-intent-curator to record the dangling sources/chain edge as a " \
+      "Dispatch plastic-store-curating to record the dangling sources/chain edge as a " \
       "broken-source/broken-chain move-and-record entry in the intent's revisions.md (see " \
       "PLASTIC.md > Structural maintenance and revisions.md), or restore the missing intent"
     )
@@ -1052,6 +1107,11 @@ class Doctor
     # skills_exist — flat, hyphen-namespaced personal skills (plastic-<name>/)
     checks << flat_skills_check(agent_dir, "--claude")
 
+    # stray_skills — installed plastic-* skill dir with no manifest entry (a leftover,
+    # e.g. an old-name copy after a rename; intent 158a AC15)
+    stray_check = stray_skills_check(agent_dir, "--claude", File.join(agent_dir, "plastic", "manifest.json"))
+    checks << stray_check if stray_check
+
     # agents_exist — auto-mode role files (plastic-*.md) synced into <dir>/agents
     checks << flat_agents_check(agent_dir, "--claude")
 
@@ -1078,6 +1138,43 @@ class Doctor
     end
   end
 
+  # Backstop for a rename or removal (intent 158a, AC15): an installed plastic-*
+  # skill directory under agent_dir/skills that has NO corresponding entry in the
+  # current install manifest is a stray (e.g. a leftover old-name copy the
+  # install/update prune should have removed, or one it never saw because the
+  # manifest predates it). Complements flat_skills_check (which only confirms at
+  # least one skill exists). Defers to the manifest check when the manifest itself
+  # is missing or malformed, so the two checks never double-report the same gap.
+  def stray_skills_check(agent_dir, installer_flag, manifest_path)
+    skills_root = File.join(agent_dir, "skills")
+    manifest = read_json_safe(manifest_path)
+    files = manifest.is_a?(Hash) ? manifest["files"] : nil
+    return nil unless files.is_a?(Hash)
+
+    installed = Dir.glob(File.join(skills_root, "plastic-*", "SKILL.md"))
+                    .map { |f| File.basename(File.dirname(f)) }
+    tracked = files.keys
+                   .select { |p| p.start_with?("#{skills_root}/") }
+                   .map { |p| p.sub("#{skills_root}/", "").split("/").first }
+                   .uniq
+
+    strays = (installed - tracked).sort
+
+    if strays.empty?
+      check(
+        category: "agent_registration", name: "stray_skills", status: "pass",
+        message: "No stray plastic-* skill directories in #{tilde(skills_root)}"
+      )
+    else
+      check(
+        category: "agent_registration", name: "stray_skills", status: "warn",
+        message: "#{strays.size} installed skill dir(s) not in the current manifest (stray, e.g. a leftover old-name copy)",
+        details: strays,
+        fixable: true, fix_hint: "Re-run the Plastic installer: npx @zalom/plastic@latest #{installer_flag}"
+      )
+    end
+  end
+
   # Auto-mode role agents install as <dir>/agents/plastic-*.md. Pass if at least
   # one such role file is present (the installer syncs agents/ on every install).
   def flat_agents_check(agent_dir, installer_flag)
@@ -1104,6 +1201,12 @@ class Doctor
 
     # For codex/hermes: just check skills exist (no settings.json hooks)
     checks << flat_skills_check(agent_dir, "--#{agent_key}")
+
+    # stray_skills — installed plastic-* skill dir with no manifest entry (a leftover,
+    # e.g. an old-name copy after a rename; intent 158a AC15)
+    stray_check = stray_skills_check(agent_dir, "--#{agent_key}", File.join(agent_dir, "plastic-manifest.json"))
+    checks << stray_check if stray_check
+
     checks << flat_agents_check(agent_dir, "--#{agent_key}")
 
     checks
@@ -1223,9 +1326,85 @@ class Doctor
       end
     end
 
+    checks += check_agent_model_drift(agent_key)
+
     checks
   end
 
+  # agent_model_drift - advisory (never fail) config-vs-frontmatter comparison
+  # for every installed <agent_dir>/agents/plastic-*.md file (intent 170, D1).
+  # Resolution mirrors read-config's own precedence (project override -> global
+  # override -> shipped AgentModels::TIER_DEFAULTS), reusing AgentModels'
+  # `override_map` directly so this stays hermetically DI-testable (no
+  # shell-out to `read-config`, no ENV/global seam). There is no live project
+  # scope at doctor-run time for a globally-installed agent file, so the
+  # project layer is empty here; the resolver still supports one, matching the
+  # same `override_map(project_config:, global_config:)` shape the installer
+  # already calls.
+  #
+  # Classification per installed agent basename:
+  #   - no `agents.models.<basename>` override AND frontmatter == resolved
+  #     default -> pass (clean)
+  #   - no override AND frontmatter != resolved default -> warn (real drift)
+  #   - an override IS configured -> pass/informational, LISTED as a
+  #     sanctioned override, regardless of whether frontmatter matches (that
+  #     mismatch is the override working, e.g. `plastic-brainstorming: fable`)
+  #   - zero installed agent files -> pass (nothing to check)
+  # This check never returns "fail".
+  def check_agent_model_drift(agent_key)
+    agent_config = agents[agent_key]
+    return [] unless agent_config
+
+    agents_dir = File.join(agent_config[:dir], "agents")
+    installed = Dir.glob(File.join(agents_dir, "plastic-*.md")).sort
+
+    if installed.empty?
+      return [check(
+        category: "core_files", name: "agent_model_drift", status: "pass",
+        message: "No installed plastic-* agent files to check for model drift"
+      )]
+    end
+
+    global_config = load_yaml_safe(File.join(plastic_home, "config.yml")) || {}
+    overrides = AgentModels.override_map(project_config: {}, global_config: global_config)
+
+    drifted = []
+    sanctioned = []
+
+    installed.each do |path|
+      basename = File.basename(path, ".md")
+      installed_model = (parse_frontmatter(path) || {})["model"]
+      resolved_default = AgentModels::TIER_DEFAULTS[basename]
+      override = overrides[basename]
+
+      if override
+        sanctioned << "#{basename}: frontmatter=#{installed_model.inspect}, sanctioned override=#{override.inspect}"
+      elsif installed_model != resolved_default
+        drifted << "#{basename}: frontmatter=#{installed_model.inspect}, resolved default=#{resolved_default.inspect}"
+      end
+    end
+
+    if drifted.empty?
+      message = if sanctioned.empty?
+                  "No agent-model drift (#{installed.size} installed agent(s) match the resolved default)"
+                else
+                  "No unsanctioned agent-model drift; #{sanctioned.size} sanctioned override(s) in effect"
+                end
+      [check(
+        category: "core_files", name: "agent_model_drift", status: "pass",
+        message: message,
+        details: sanctioned
+      )]
+    else
+      [check(
+        category: "core_files", name: "agent_model_drift", status: "warn",
+        message: "#{drifted.size} installed agent(s) have unsanctioned model drift vs the config-resolved default",
+        details: drifted + sanctioned,
+        fixable: false
+      )]
+    end
+  end
+
   # --- Check category: manifest sync (binary core integrity) ---
 
   # Verify, for BOTH the global manifest and the agent-side manifest, that every
@@ -1405,7 +1584,7 @@ class Doctor
       checks << check(
         category: "project_stores", name: "project_yml_exists", status: "warn",
         message: "project.yml missing for project '#{slug}'",
-        fixable: true, fix_hint: "Create project.yml from template — see plastic-creating-project"
+        fixable: true, fix_hint: "Create project.yml from template — see plastic-project-creating"
       )
     end
 
@@ -1753,4 +1932,4 @@ class Doctor
 
 end
 
-Doctor.new.cli(ARGV) if $PROGRAM_NAME == __FILE__
+Doctor.new(plastic_home: ENV.fetch("PLASTIC_HOME") { Doctor::DEFAULT_PLASTIC_HOME }).cli(ARGV) if $PROGRAM_NAME == __FILE__

package/scripts/end-intent

@@ -0,0 +1,330 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# end-intent (intent 161) - the mechanical core of the single owned Done
+# procedure (D2 steps 1-4). Pure with respect to worktrees, locks, and QMD:
+# those stay in the plastic-intent-ending skill body (steps 0 and 5-7), never
+# duplicated here. Pairs new-intent's shape: one callable script instead of
+# raw one-liners repeated in skill prose (the failure mode this intent fixes).
+#
+# Usage:
+#   end-intent --store <store_path> --id <intent_id> --disposition delivered|abandoned \
+#              [--index <path>] [--outcome-summary <text>] [--index-note <text>] \
+#              [--no-commit] [--dry-run]
+#
+# Steps performed (in order), all idempotent:
+#   1. Guard outcome.md (exit 2, authors nothing, on any failure), then stamp
+#      the intent file's `## Outcome` section with --outcome-summary if given.
+#   2. Move the intent's INDEX.md line from `## Active` into `## Completed`
+#      (delivered) or `## Abandoned` (abandoned), dated today, appending
+#      --index-note (if given) after the date so the terminal entry stays
+#      the store's existing rich Completed/Abandoned shape rather than
+#      thinning to bare id+date.
+#   3. Append the savepoint `Done` bookend (Bridge.append_terminal_savepoint).
+#   4. Commit the store repo, unless --no-commit.
+#
+# Exit codes: 0 (ok), 1 (usage/resolution failure), 2 (outcome.md guard refused).
+
+require "fileutils"
+require "date"
+require "open3"
+require_relative "lib/bridge"
+require_relative "lib/intent_validator"
+
+DISPOSITIONS = %w[delivered abandoned].freeze
+
+# The store-line separator this script must reproduce is a real em dash
+# (U+2014), the existing INDEX.md convention (store files are exempt from the
+# no-em-dash shipped-file rule). Built from the codepoint, not a literal byte
+# in this source file, so the script's own source stays em-dash free.
+EM_DASH = "\u2014"
+
+# --- Explicit flag parsing (no eval, no global injection) -------------------
+
+def parse_args(argv)
+  opts = {
+    store: nil, id: nil, disposition: nil, index: nil,
+    outcome_summary: nil, index_note: nil, no_commit: false, dry_run: false,
+  }
+  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 "--disposition"     then opts[:disposition] = argv[i += 1]
+    when "--index"           then opts[:index] = argv[i += 1]
+    when "--outcome-summary" then opts[:outcome_summary] = argv[i += 1]
+    when "--index-note"      then opts[:index_note] = argv[i += 1]
+    when "--no-commit"       then opts[:no_commit] = true
+    when "--dry-run"         then opts[:dry_run] = true
+    else
+      usage_abort("unknown argument #{arg.inspect}")
+    end
+    i += 1
+  end
+  opts
+end
+
+def usage
+  "usage: end-intent --store <store_path> --id <intent_id> " \
+    "--disposition delivered|abandoned [--index <path>] " \
+    "[--outcome-summary <text>] [--index-note <text>] [--no-commit] [--dry-run]"
+end
+
+def usage_abort(message)
+  warn "end-intent: #{message}"
+  warn usage
+  exit 1
+end
+
+def expand(path)
+  File.expand_path(path.to_s.sub(/\A~/, Dir.home))
+end
+
+# Resolve the single "<store>/<id>--*" directory, or abort (usage error: exit 1).
+def resolve_intent_dir(store, id)
+  matches = Dir.glob(File.join(store, "#{id}--*")).select { |d| File.directory?(d) }
+  usage_abort("no intent directory matches #{id}--* under #{store}") if matches.empty?
+  if matches.length > 1
+    usage_abort("ambiguous id #{id.inspect}: #{matches.length} matching directories under #{store}")
+  end
+  matches.first
+end
+
+# --- outcome.md guard (D2 step 1a) ------------------------------------------
+#
+# Returns nil when the guard PASSES, or a reason String to refuse with exit 2.
+# Read-only: authors nothing regardless of outcome. Refuses a missing file, a
+# still-placeholder file (first line is the sentinel), or a disposition that
+# does not exactly equal the requested one (this is what naturally refuses a
+# freshly scaffolded outcome.md, whose disposition is the literal
+# "delivered|abandoned" string, not one of the two real values).
+def outcome_guard_reason(intent_dir, disposition)
+  path = File.join(intent_dir, "outcome.md")
+  return "outcome.md is missing at #{path}" unless File.exist?(path)
+
+  content = File.read(path)
+  first_line = content.each_line.first.to_s.chomp
+  if first_line == Bridge::PLACEHOLDER_SENTINEL
+    return "outcome.md is still the scaffold placeholder (first line is the sentinel)"
+  end
+
+  fm = IntentValidator.parse_frontmatter_text(content)
+  actual = fm.is_a?(Hash) ? fm["disposition"] : nil
+  unless DISPOSITIONS.include?(actual) && actual == disposition
+    return "outcome.md frontmatter disposition is #{actual.inspect}, expected #{disposition.inspect}"
+  end
+
+  nil
+end
+
+# --- intent-file `## Outcome` summary stamp (D2 step 1b) --------------------
+#
+# Replace the body of the intent file's `## Outcome` section with `summary`,
+# leaving every other section and the frontmatter untouched. No-op (returns
+# content unchanged) when summary is blank or the section is not found.
+def stamp_outcome_summary(content, summary)
+  return content if summary.nil? || summary.to_s.strip.empty?
+
+  lines = content.lines
+  start = lines.index { |l| l.rstrip == "## Outcome" }
+  return content if start.nil?
+
+  stop = start + 1
+  stop += 1 while stop < lines.length && !lines[stop].start_with?("## ")
+
+  body = "#{summary.to_s.strip}\n"
+  replacement = (stop < lines.length) ? [body, "\n"] : [body]
+  (lines[0..start] + replacement + lines[stop..]).join
+end
+
+# --- INDEX.md terminal move (D2 step 2) -------------------------------------
+
+ACTIVE_LINE_RE = /\A- \[(\S+)\s+#{Regexp.escape(EM_DASH)}\s+(.*?)\]\(([^)]+)\)/.freeze
+
+def index_target_heading(disposition)
+  disposition == "delivered" ? "## Completed" : "## Abandoned"
+end
+
+# Index of the first `## ` heading at or after heading_idx + 1, or lines.length
+# at EOF (the section's exclusive end bound).
+def section_stop(lines, heading_idx)
+  stop = heading_idx + 1
+  stop += 1 while stop < lines.length && !lines[stop].start_with?("## ")
+  stop
+end
+
+def active_line_id(line)
+  m = line.match(ACTIVE_LINE_RE)
+  m && m[1]
+end
+
+def section_contains_id?(lines, heading_idx, id)
+  stop = section_stop(lines, heading_idx)
+  (heading_idx + 1...stop).any? { |i| active_line_id(lines[i]) == id }
+end
+
+# Remove the entry at entry_idx from the `## Active` section. When no real
+# entries remain, install the canonical "_(none)_" placeholder (the same
+# empty-state convention INDEX.md already uses).
+def remove_active_entry(lines, active_start, entry_idx)
+  new_lines = lines.dup
+  new_lines.delete_at(entry_idx)
+  stop = section_stop(new_lines, active_start)
+  remaining = (active_start + 1...stop).reject { |i| new_lines[i].strip.empty? }
+  if remaining.empty?
+    # Keep the blank-line separator before the next heading (if any); only
+    # collapse the section body to the placeholder, never the spacing.
+    placeholder = (stop < new_lines.length) ? ["_(none)_\n", "\n"] : ["_(none)_\n"]
+    new_lines[(active_start + 1)...stop] = placeholder
+  end
+  new_lines
+end
+
+# Insert new_entry into the target terminal section: replace the "_(none)_"
+# placeholder if that is the ONLY non-blank content the section holds (a
+# trailing blank line before the next heading is common and must not
+# defeat this check), otherwise prepend (newest-first, matching the
+# existing Completed/Abandoned convention).
+def insert_terminal_entry(lines, target_start, new_entry)
+  new_lines = lines.dup
+  stop = section_stop(new_lines, target_start)
+  body_range = (target_start + 1...stop)
+  placeholder_idx = body_range.find { |i| new_lines[i].strip == "_(none)_" }
+  non_blank = body_range.reject { |i| new_lines[i].strip.empty? }
+  if placeholder_idx && non_blank == [placeholder_idx]
+    new_lines[placeholder_idx] = new_entry
+  else
+    new_lines.insert(target_start + 1, new_entry)
+  end
+  new_lines
+end
+
+# Move the intent's `## Active` line into the terminal section. Returns the
+# new INDEX.md content, or the original content unchanged when there is
+# nothing to do (idempotent: a second run finds no Active entry and the
+# terminal section already carries it, so it is a clean no-op). `index_note`
+# (D2 "rich entry", review F3), when given, is appended verbatim after the
+# date with a single leading space: content authoring (mode/tier, what
+# shipped, suite result, and so on) stays with the caller, this only places
+# the text where the store's existing Completed/Abandoned lines carry it.
+def move_index_to_terminal(content, id, disposition, today:, index_note: nil)
+  target_heading = index_target_heading(disposition)
+  lines = content.lines
+
+  active_start = lines.index { |l| l.rstrip == "## Active" }
+  target_start = lines.index { |l| l.rstrip == target_heading }
+  return content if active_start.nil? || target_start.nil?
+
+  already_in_target = section_contains_id?(lines, target_start, id)
+  active_stop = section_stop(lines, active_start)
+  entry_idx = (active_start + 1...active_stop).find { |i| active_line_id(lines[i]) == id }
+
+  return content if entry_idx.nil? # already moved (or never present): no-op either way
+
+  m = lines[entry_idx].match(ACTIVE_LINE_RE)
+  title, link = m[2], m[3]
+  note_suffix = (index_note && !index_note.to_s.strip.empty?) ? " #{index_note.to_s.strip}" : ""
+  new_entry = "- [#{id} #{EM_DASH} #{title}](#{link}) #{EM_DASH} #{today}#{note_suffix}\n"
+
+  lines = remove_active_entry(lines, active_start, entry_idx)
+  target_start = lines.index { |l| l.rstrip == target_heading }
+  lines = insert_terminal_entry(lines, target_start, new_entry) unless already_in_target
+
+  lines.join
+end
+
+# --- store auto-commit (D2 step 4) ------------------------------------------
+
+def git_toplevel(dir)
+  out, _err, status = Open3.capture3("git", "-C", dir, "rev-parse", "--show-toplevel")
+  return nil unless status.success?
+  top = out.strip
+  top.empty? ? nil : top
+end
+
+# Best-effort store commit: never raises, never blocks the mechanical close.
+# Returns true when a commit was created, false otherwise (not a git repo,
+# nothing to commit, or the commit failed). Pins a local committer identity so
+# the commit succeeds even with no ambient git config (hermetic).
+def store_commit(store, id, disposition)
+  root = git_toplevel(store)
+  return false if root.nil?
+
+  Open3.capture3("git", "-C", root, "add", "-A")
+  _out, _err, status = Open3.capture3(
+    "git", "-C", root,
+    "-c", "user.name=Plastic", "-c", "user.email=plastic@localhost",
+    "commit", "--quiet", "-m", "chore: complete intent #{id} (#{disposition})"
+  )
+  status.success?
+end
+
+# --- main --------------------------------------------------------------------
+
+def main(argv)
+  opts = parse_args(argv)
+  usage_abort("--store is required") if opts[:store].nil? || opts[:store].empty?
+  usage_abort("--id is required") if opts[:id].nil? || opts[:id].empty?
+  unless DISPOSITIONS.include?(opts[:disposition])
+    usage_abort("--disposition must be one of #{DISPOSITIONS.join('|')}")
+  end
+
+  store = expand(opts[:store])
+  usage_abort("store dir does not exist: #{store}") unless Dir.exist?(store)
+
+  id = opts[:id]
+  disposition = opts[:disposition]
+  intent_dir = resolve_intent_dir(store, id)
+  index_path = opts[:index] ? expand(opts[:index]) : File.join(File.dirname(store), "INDEX.md")
+  today = Date.today.iso8601
+
+  reason = outcome_guard_reason(intent_dir, disposition)
+  if reason
+    warn "end-intent: #{reason}"
+    exit 2
+  end
+
+  if opts[:dry_run]
+    puts "end-intent: dry run for #{File.basename(intent_dir)} (#{disposition})"
+    puts "  would stamp ## Outcome: #{opts[:outcome_summary].inspect}" if opts[:outcome_summary]
+    puts "  would move INDEX.md entry from ## Active to #{index_target_heading(disposition)} (#{index_path})"
+    puts "  would append index note: #{opts[:index_note].inspect}" if opts[:index_note]
+    puts "  would append savepoint bookend: Done  #{disposition}"
+    puts(opts[:no_commit] ? "  would skip store commit (--no-commit)" : "  would commit the store repo")
+    exit 0
+  end
+
+  # 1b. Intent-file `## Outcome` summary stamp (no-op unless given).
+  if opts[:outcome_summary]
+    intent_file = Bridge.intent_file(intent_dir)
+    if File.exist?(intent_file)
+      original = File.read(intent_file)
+      updated = stamp_outcome_summary(original, opts[:outcome_summary])
+      File.write(intent_file, updated) if updated != original
+    end
+  end
+
+  # 2. INDEX.md terminal move.
+  if File.exist?(index_path)
+    original_index = File.read(index_path)
+    updated_index = move_index_to_terminal(original_index, id, disposition, today: today,
+                                            index_note: opts[:index_note])
+    File.write(index_path, updated_index) if updated_index != original_index
+  else
+    warn "end-intent: INDEX.md not found at #{index_path}, skipping the terminal move"
+  end
+
+  # 3. Savepoint Done bookend (idempotent).
+  Bridge.append_terminal_savepoint(intent_dir, disposition)
+
+  # 4. Store auto-commit, unless --no-commit.
+  store_commit(store, id, disposition) unless opts[:no_commit]
+
+  puts intent_dir
+  exit 0
+end
+
+main(ARGV) if $PROGRAM_NAME == __FILE__

package/scripts/hook-code-gate

@@ -39,7 +39,7 @@ if new_content && Bridge::PLASTIC_OK_RE.match?(new_content.chomp)
 end
 
 # --- Load bridge (shared resolution; stdin session_id -> CLAUDE_CODE_SESSION_ID -> /tmp scan) ---
-bridge_data = Bridge.discover_bridge(session: session, cwd: file_path)
+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) ||

package/scripts/hook-continue

@@ -20,8 +20,8 @@ exit 0 unless status.success? && !cockpit.strip.empty?
 
 context = cockpit.rstrip +
   "\n\nFollow the plastic-continuing skill workflow to resume: " \
-  "if active intents exist, read their state and resume; otherwise offer the " \
-  "Value×Effort matrix items above, surfacing any stale (Nd) / ⚑ triage intents."
+  "if active intents exist, read their state and resume; otherwise surface the " \
+  "most-valuable next work and any stale or triage intents from the board above."
 
 payload = {
   "hookSpecificOutput" => {

package/scripts/hook-create-gate

@@ -67,7 +67,7 @@ result =
     # the validator.
     unless File.exist?(abs)
       block!("PLASTIC CREATE GATE — #{File.basename(abs)} does not exist; " \
-             "create intents via new-intent / plastic-creating-intent.")
+             "create intents via new-intent / plastic-intent-creating.")
     end
     current = File.read(abs)
     unless current.include?(old_string)
@@ -91,5 +91,5 @@ exit 0 if result[:ok]
 
 $stderr.puts "PLASTIC CREATE GATE — #{File.basename(abs)} is not a valid intent:"
 result[:errors].each { |e| $stderr.puts "  #{e}" }
-$stderr.puts "Create intents via new-intent / plastic-creating-intent; do not hand-author them."
+$stderr.puts "Create intents via new-intent / plastic-intent-creating; do not hand-author them."
 exit 2