@zalom/plastic 1.14.0 → 2.0.0-alpha.1

package/scripts/lib/savepoint.rb

@@ -0,0 +1,320 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Savepoint: the intent-directory savepoint ledger and the stage derivation it
+# rests on (intent 303, split out of bridge.rb). Everything here is derived from
+# the files on disk inside one intent directory: which lifecycle files are real
+# (not the placeholder sentinel), which stage that makes, and the append-only
+# savepoint.md ledger that records each milestone. No session, no bridge, no
+# lock: a caller that only wants to append a ledger line or ask "which stage is
+# this intent at" loads this file and nothing else. bridge.rb (the session
+# pointer, arm and disarm, lock repair) requires this file; this file never
+# requires the bridge.
+require "fileutils"
+require "time" # Time#iso8601 for the ledger timestamps
+
+module Savepoint
+  # Placeholder sentinel (intent 60b). A scaffolded lifecycle file
+  # (spec.md/plan.md/checklist.md/outcome.md) carries this exact string as its
+  # first line until an agent fills the file and deletes the sentinel. The
+  # sentinel is the "stage not reached yet" marker, so stage detection treats a
+  # sentinel-marked file as absent (see stage_file_present?). The intent file
+  # (<id>--<slug>.md) is never sentineled; it is born complete.
+  PLACEHOLDER_SENTINEL = "<!-- plastic:placeholder -->"
+
+  def self.intent_file(intent_dir)
+    dir_name = File.basename(intent_dir)
+    "#{intent_dir}/#{dir_name}.md"
+  end
+
+  # Walk up from file_path; return the first ancestor that looks like an intent
+  # directory (`.../store/<id>--<slug>`), else nil. Used to derive the savepoint
+  # target without needing a bridge. The input is always a file inside the intent
+  # dir (never the dir itself), so the walk-up starts at its parent.
+  def self.intent_dir_for(file_path)
+    dir = File.expand_path(file_path)
+    loop do
+      parent = File.dirname(dir)
+      break if parent == dir # reached filesystem root
+      dir = parent
+      return dir if dir.match?(%r{/store/[^/]+--[^/]+\z})
+    end
+    nil
+  end
+
+  # True iff a lifecycle file is PRESENT AND REAL: it exists and its first line is
+  # not the placeholder sentinel. Reads only the file head (never the whole file)
+  # so the dashboard stays fast across many intents. Exact first-line match only,
+  # so a real file that merely contains an HTML comment later is unaffected, and a
+  # partially-edited sentinel reads as real rather than sticking as a placeholder.
+  def self.stage_file_present?(path)
+    return false unless File.exist?(path)
+    first = File.open(path, &:gets)
+    return true if first.nil? # empty file: present, not a sentinel
+    first.chomp != PLACEHOLDER_SENTINEL
+  rescue StandardError
+    File.exist?(path)
+  end
+
+  # True iff actions/ holds AT LEAST ONE real action file: a non-empty *.md whose
+  # first line is not the placeholder sentinel. A `.gitkeep` (no .md extension)
+  # never counts, an empty *.md never counts, and a sentinel-only *.md never
+  # counts. Pure and side-effect-free so the gate stays unit-testable. Fail-open:
+  # a missing actions/ dir globs to nothing and returns false (the gate then
+  # reports it needs a real action file); it never raises.
+  def self.has_real_action?(intent_dir)
+    Dir.glob("#{intent_dir}/actions/*.md").any? do |f|
+      File.file?(f) && File.size(f) > 0 && stage_file_present?(f)
+    end
+  rescue StandardError
+    false
+  end
+
+  def self.derive_stage(intent_dir)
+    return "done" if stage_file_present?("#{intent_dir}/outcome.md")
+    if stage_file_present?("#{intent_dir}/plan.md") &&
+       has_real_action?(intent_dir) &&
+       stage_file_present?("#{intent_dir}/checklist.md")
+      return "exec"
+    end
+    return "how" if stage_file_present?("#{intent_dir}/spec.md")
+    return "why" if File.exist?(intent_file(intent_dir))
+    "what"
+  end
+
+  def self.has_files(intent_dir)
+    files = []
+    ifile = File.basename(intent_file(intent_dir))
+    files << ifile if File.exist?("#{intent_dir}/#{ifile}")
+    ["spec.md", "plan.md", "checklist.md", "outcome.md"].each do |f|
+      files << f if stage_file_present?("#{intent_dir}/#{f}")
+    end
+    files << "actions/" if has_real_action?(intent_dir)
+    files
+  end
+
+  def self.missing_for_stage(stage, intent_dir = nil)
+    ifile = intent_dir ? File.basename(intent_file(intent_dir)) : "intent.md"
+    case stage
+    when "what" then [ifile]
+    when "why" then ["spec.md"]
+    when "how" then ["plan.md", "actions/", "checklist.md"]
+    when "exec" then ["outcome.md"]
+    else []
+    end
+  end
+
+  # --- Cycle-step savepoint ledger (intent 34) ------------------------------
+  #
+  # savepoint.md is a deterministic, append-only, one-line-per-milestone ledger
+  # (newest at the bottom). It is sugar on top of the conventions: derived from
+  # files-on-disk, rebuildable, never a source of truth. Milestones are
+  # file-event boundaries only; action/resource files record nothing.
+
+  SAVEPOINT_FILE = "savepoint.md"
+
+  # Map a written filename to [stage_label, milestone_text], or nil if the file
+  # is not a lifecycle milestone.
+  def self.savepoint_milestone(intent_dir, basename)
+    return ["What", basename] if basename == File.basename(intent_file(intent_dir))
+
+    case basename
+    when "spec.md"      then ["Why", "spec.md created"]
+    when "plan.md"      then ["How", "plan.md created"]
+    when "checklist.md" then ["How", "checklist.md created"]
+    when "outcome.md"   then ["Exec", "outcome.md created"]
+    end
+  end
+
+  # Milestones already recorded in the ledger (field 3 of each line).
+  def self.savepoint_recorded_milestones(intent_dir)
+    f = File.join(intent_dir, SAVEPOINT_FILE)
+    return [] unless File.exist?(f)
+    File.read(f).each_line.map do |line|
+      parts = line.strip.split(/\s{2,}/)
+      parts.length >= 3 ? parts[2] : nil
+    end.compact
+  end
+
+  # (stage, milestone) pairs already recorded in the ledger. The pair (not the
+  # milestone text alone) is the dedup key, because state-from-ledger lines like
+  # `Why  started` and `How  started` share the milestone text "started" while
+  # being distinct events (intent 81).
+  def self.savepoint_recorded_pairs(intent_dir)
+    f = File.join(intent_dir, SAVEPOINT_FILE)
+    return [] unless File.exist?(f)
+    File.read(f).each_line.filter_map do |line|
+      parts = line.strip.split(/\s{2,}/)
+      parts.length >= 3 ? [parts[1], parts[2]] : nil
+    end
+  end
+
+  # Append one ledger line for (stage, milestone) unless that pair is already
+  # recorded. The single append primitive shared by every line class. Returns
+  # true when a line was written, false when it was a no-op.
+  def self.append_savepoint_line(intent_dir, stage, milestone, now)
+    return false if savepoint_recorded_pairs(intent_dir).include?([stage, milestone])
+    line = "#{now.utc.iso8601}  #{stage}  #{milestone}\n"
+    File.open(File.join(intent_dir, SAVEPOINT_FILE), "a") { |io| io.write(line) }
+    true
+  end
+
+  # Append the artifact-landing milestone for file_path if (and only if) it is a
+  # milestone not already recorded. Returns true when a line was written.
+  def self.append_savepoint(intent_dir, file_path, now: Time.now)
+    basename = File.basename(file_path)
+    stage, milestone = savepoint_milestone(intent_dir, basename)
+    return false unless milestone
+    # A sentinel-marked lifecycle file logs NO milestone (the stage is not real
+    # yet). The intent file is never sentineled, so it still logs its What line.
+    return false unless stage_file_present?(File.join(intent_dir, basename))
+
+    append_savepoint_line(intent_dir, stage, milestone, now)
+  end
+
+  # --- State-from-ledger: pre-stage, exec-start, and terminal lines (81) ------
+  #
+  # On top of intent 34's artifact-landing milestones, the ledger gains:
+  #   - `started` lines, one per cycle stage entry (pre-stage, written by the
+  #     PreToolUse savepoint hook the moment a stage's artifact is first written);
+  #   - an `Exec  started` companion emitted when checklist.md lands;
+  #   - a terminal `Done  delivered|abandoned` line written by the completion path.
+  # None of these are derivable from files on disk, so they are deliberately NOT
+  # part of savepoint_milestone and are never regenerated by rebuild_savepoint:
+  # a rebuilt ledger is the file-landing skeleton, the live ledger is richer.
+
+  # Map a written filename to the [stage, "started"] pre-stage milestone, or nil.
+  # spec.md => entering Why, plan.md => entering How. checklist.md/outcome.md do
+  # not open a stage (checklist's Exec-start is the append_exec_started companion).
+  def self.savepoint_started_milestone(basename)
+    case basename
+    when "spec.md" then ["Why", "started"]
+    when "plan.md" then ["How", "started"]
+    end
+  end
+
+  # Append the pre-stage `started` line for file_path, iff: the basename opens a
+  # stage, the stage is genuinely starting (its artifact is not yet a REAL file,
+  # so a sentinel placeholder still counts as "starting"), and the pair is not
+  # already recorded. Returns true when a line was written.
+  def self.append_started_savepoint(intent_dir, file_path, now: Time.now)
+    basename = File.basename(file_path)
+    stage, milestone = savepoint_started_milestone(basename)
+    return false unless milestone
+    return false if stage_file_present?(File.join(intent_dir, basename))
+
+    append_savepoint_line(intent_dir, stage, milestone, now)
+  end
+
+  # Append the `Exec  started` companion (emitted when checklist.md lands, in the
+  # same PostToolUse event as the `How  checklist.md created` line). Idempotent.
+  def self.append_exec_started(intent_dir, now: Time.now)
+    append_savepoint_line(intent_dir, "Exec", "started", now)
+  end
+
+  TERMINAL_DISPOSITIONS = %w[delivered abandoned].freeze
+
+  # Append the terminal bookend `Done  delivered|abandoned`, written by the
+  # completion path when an intent transfers to INDEX's Completed/Abandoned
+  # section. Idempotent per disposition. Raises on an unknown disposition.
+  def self.append_terminal_savepoint(intent_dir, disposition, now: Time.now)
+    unless TERMINAL_DISPOSITIONS.include?(disposition)
+      raise ArgumentError,
+            "disposition must be one of #{TERMINAL_DISPOSITIONS.join(', ')}, got #{disposition.inspect}"
+    end
+
+    append_savepoint_line(intent_dir, "Done", disposition, now)
+  end
+
+  # Reconstruct the ledger from files on disk (timestamps from mtimes), in
+  # stage order, overwriting savepoint.md. Returns the number of lines written.
+  # A Plastic 1.x ledger may carry a `Tier  <value>` line after the spec.md
+  # milestone (removed in 2.0, intent 304); a rebuild drops it, and the phantom
+  # detector ignores it, so a 1.x store reads clean.
+  def self.rebuild_savepoint(intent_dir)
+    ordered = [
+      File.basename(intent_file(intent_dir)),
+      "spec.md", "plan.md", "checklist.md", "outcome.md",
+    ]
+    lines = ordered.flat_map do |basename|
+      path = File.join(intent_dir, basename)
+      next [] unless stage_file_present?(path)
+      stage, milestone = savepoint_milestone(intent_dir, basename)
+      next [] unless milestone
+      stamp = File.mtime(path).utc.iso8601
+      ["#{stamp}  #{stage}  #{milestone}\n"]
+    end
+    File.write(File.join(intent_dir, SAVEPOINT_FILE), lines.join)
+    lines.length
+  end
+
+  # --- Phantom-line detection (intent 134) ------------------------------------
+  #
+  # A companion to the ledger, not a new writer: pure, disk-only, hermetic (no bridge or
+  # session resolution, no writes), matching intent 52's savepoint-decoupling precedent. Under
+  # a gate-routing misfire (bug 131) or an out-of-band merge (124a's precedent), a ledger line
+  # can go stale or duplicate without the file evidence agreeing. This detects, never repairs;
+  # repair is `rebuild_savepoint` (live intents) or the 124a manual Done-bookend recipe
+  # (terminal intents, human-granted only).
+
+  # (stage, milestone) -> basename, for every file-landing milestone this intent_dir could have
+  # produced (the intent file plus the four lifecycle artifacts). Reuses savepoint_milestone so
+  # the mapping never drifts from the one the writer itself uses.
+  def self.savepoint_file_landing_pairs(intent_dir)
+    basenames = [File.basename(intent_file(intent_dir)), "spec.md", "plan.md", "checklist.md", "outcome.md"]
+    basenames.each_with_object({}) do |basename, map|
+      pair = savepoint_milestone(intent_dir, basename)
+      map[pair] = basename if pair
+    end
+  end
+
+  # A `started` state line's real prerequisite is the PRECEDING stage's artifact, not its own
+  # (a `started` line legitimately fires before its own stage's file is real by design). `Exec
+  # started` additionally requires plan.md, since Exec cannot start before How produced it too.
+  SAVEPOINT_STATE_PREREQUISITES = {
+    ["How", "started"] => ["spec.md"],
+    ["Exec", "started"] => ["plan.md", "checklist.md"],
+  }.freeze
+
+  # Raw (stripped) ledger lines whose disk evidence contradicts them, each paired with a short
+  # reason: [line, reason]. Three phantom classes (D5):
+  #   - a file-landing milestone whose file is absent or still a sentinel placeholder;
+  #   - a duplicate (stage, milestone) pair (the later occurrence is the phantom);
+  #   - a state line (`How started` / `Exec started`) whose stage prerequisites are absent.
+  # A clean ledger, or an absent one, returns [].
+  def self.savepoint_phantom_lines(intent_dir)
+    path = File.join(intent_dir, SAVEPOINT_FILE)
+    return [] unless File.exist?(path)
+
+    landing = savepoint_file_landing_pairs(intent_dir)
+    seen = []
+    phantoms = []
+
+    File.read(path).each_line do |raw|
+      line = raw.strip
+      next if line.empty?
+      parts = line.split(/\s{2,}/)
+      next if parts.length < 3
+      pair = [parts[1], parts[2]]
+
+      if seen.include?(pair)
+        phantoms << [line, "duplicate (stage, milestone) pair"]
+        next
+      end
+      seen << pair
+
+      if (basename = landing[pair]) && !stage_file_present?(File.join(intent_dir, basename))
+        phantoms << [line, "milestone file absent or still a sentinel placeholder"]
+        next
+      end
+
+      prereqs = SAVEPOINT_STATE_PREREQUISITES[pair]
+      if prereqs && prereqs.any? { |b| !stage_file_present?(File.join(intent_dir, b)) }
+        phantoms << [line, "state line prerequisite absent on disk"]
+      end
+    end
+
+    phantoms
+  end
+end

package/scripts/lib/scaffold_intent.rb

@@ -4,20 +4,21 @@
 require "fileutils"
 require_relative "worktree"
 require_relative "bridge"
-require_relative "spec_header"
+require_relative "savepoint"
 require_relative "intent_validator"
 
-# ScaffoldIntent - all logic for `scripts/scaffold-intent` (intent 213). Three
-# subcommands (spec|checklist|outcome), each writes one lifecycle artifact by copying or
-# mechanically deriving it from an already-committed source: the intent file's
-# `### Decisions` list, spec.md's `## Acceptance Criteria` list, or a `git diff --stat`
-# plus an optional supplied test-summary file. No subcommand interprets or invents prose;
-# a field this module cannot derive mechanically is left as the template's own stub text
-# instead of being guessed at.
+# ScaffoldIntent - the shared, pure helpers behind `scripts/scaffold-intent` (intent 213)
+# and its callers: path and template resolution, section splitting, the intent file's
+# `### Decisions` extraction, and the git-derived diffstat (`build_verification_body`).
+# BackfillIntent (scripts/lib/backfill_intent.rb, intent 308) composes these into the
+# one writer that fills an intent's judgment documents from its record; verify_intent,
+# exec_worktree, and session_git use the repo and base-branch helpers directly.
 #
-# `scaffold-intent` does not scaffold `actions/` in any form (intent 133a, D11): actions
-# require judgment and stay entirely with the planner. No method here creates the
-# directory, writes a `.gitkeep`, or writes a sentinel-only `ACTION_*.md`.
+# The three per-file subcommands this module once carried were removed in 2.0 (intent
+# 308): `scaffold_spec` and `scaffold_checklist` (removed in 2.0), `scaffold_outcome` with
+# `--force` and `--test-summary` (removed in 2.0). The backfill writer covers their
+# derivable targets, and nothing else called them. Nothing here invents prose: every derived field is a verbatim
+# copy or a mechanical rendering of a committed artifact.
 #
 # Pure and dependency-injected: never calls `exit` or `abort`, never reads `ARGV` or
 # `ENV` directly (only via the ambient `Dir.home` default, matching Bridge/Worktree
@@ -28,15 +29,6 @@ require_relative "intent_validator"
 module ScaffoldIntent
   module_function
 
-  SPEC_SECTIONS = [
-    "## Problem", "## Goals", "## Non-Goals", "## Approach",
-    "## Alternatives Considered", "## Decisions",
-    "## Acceptance Criteria", "## Open Questions",
-  ].freeze
-
-  SETTLED_PLACEHOLDER_COMMENT =
-    "<!-- Settled: yes (<reason>)  optional, add this line only when the design is settled -->\n"
-
   # --- path resolution (pure) --------------------------------------------------
 
   def expand(path)
@@ -84,21 +76,10 @@ module ScaffoldIntent
     { status: :ok, code: 0, message: nil, path: path }
   end
 
-  def refuse_result(path)
-    { status: :refused, code: 2, path: path,
-      message: "#{path} already has real content; pass --force to overwrite it deliberately" }
-  end
-
   def error_result(message)
     { status: :error, code: 3, message: message, path: nil }
   end
 
-  # True iff `target` exists, carries real (non-sentinel) content, and `force` was not
-  # passed: the caller must refuse to write and leave the file untouched.
-  def refuse_without_force?(target, force)
-    File.exist?(target) && Bridge.stage_file_present?(target) && !force
-  end
-
   # --- generic section helpers (pure) --------------------------------------------
 
   # Split `text` into { "## Heading" => body_text } by top-level `## ` headings (never
@@ -156,125 +137,11 @@ module ScaffoldIntent
     [body_lines.join, nil]
   end
 
-  # --- `## Acceptance Criteria` extraction from spec.md (pure) --------------------
-
-  # Byte-for-byte body of `## Acceptance Criteria` in `spec_content`. Returns
-  # [body, nil] on success, or [nil, message] when the heading is absent or its body
-  # holds no `- [ ]` line.
-  def extract_acceptance_criteria(spec_content)
-    lines = spec_content.lines
-    idx = lines.index { |l| l.rstrip == "## Acceptance Criteria" }
-    return [nil, "spec.md has no ## Acceptance Criteria section to copy"] if idx.nil?
-
-    stop = idx + 1
-    stop += 1 while stop < lines.length && !lines[stop].start_with?("## ")
-    body_lines = strip_blank_edges(lines[(idx + 1)...stop])
-
-    unless body_lines.any? { |l| l =~ /^\s*- \[ \]/ }
-      return [nil, "spec.md's ## Acceptance Criteria has no checklist items (no line matching '- [ ]')"]
-    end
-
-    [body_lines.join, nil]
-  end
-
   def strip_blank_edges(lines)
     lines = lines.drop_while { |l| l.strip.empty? }
     lines.reverse.drop_while { |l| l.strip.empty? }.reverse
   end
 
-  # --- spec subcommand ------------------------------------------------------------
-
-  def scaffold_spec(intent_dir:, force:, templates_dir: nil, home: Dir.home)
-    target = File.join(intent_dir, "spec.md")
-    return refuse_result(target) if refuse_without_force?(target, force)
-
-    intent_file = Bridge.intent_file(intent_dir)
-    return error_result("the intent file is missing at #{intent_file}") unless File.exist?(intent_file)
-
-    intent_content = File.read(intent_file)
-    fm = IntentValidator.parse_frontmatter_text(intent_content)
-    intent_name = fm.is_a?(Hash) ? fm["intent"] : nil
-    if Bridge.blank?(intent_name)
-      return error_result("the intent file at #{intent_file} has no frontmatter intent name")
-    end
-
-    decisions_body, decisions_err = extract_decisions(intent_content)
-    return error_result(decisions_err) if decisions_body.nil?
-
-    tdir = templates_dir || resolve_templates_dir(home: home)
-    return error_result(templates_missing_message(home: home)) if tdir.nil?
-
-    spec_template_path = File.join(tdir, "spec.md")
-    return error_result("spec.md template not found at #{spec_template_path}") unless File.exist?(spec_template_path)
-
-    written = build_spec_content(intent_name: intent_name, decisions_body: decisions_body,
-                                  template_text: File.read(spec_template_path))
-
-    FileUtils.mkdir_p(intent_dir)
-    File.write(target, written)
-    ok_result(target)
-  end
-
-  def build_spec_content(intent_name:, decisions_body:, template_text:)
-    template_sections = sections_from(template_text)
-
-    out = []
-    out << SpecHeader.render(tier: nil, settled_reason: nil)
-    out << SETTLED_PLACEHOLDER_COMMENT
-    out << "\n"
-    out << "# Spec: #{intent_name}\n"
-    out << "\n"
-
-    SPEC_SECTIONS.each do |heading|
-      out << "#{heading}\n"
-      if heading == "## Decisions"
-        out << decisions_body
-        out << "\n"
-      else
-        out << (template_sections[heading] || "")
-      end
-    end
-
-    out.join
-  end
-
-  # --- checklist subcommand --------------------------------------------------------
-
-  def scaffold_checklist(intent_dir:, force:, templates_dir: nil, home: Dir.home)
-    target = File.join(intent_dir, "checklist.md")
-    return refuse_result(target) if refuse_without_force?(target, force)
-
-    spec_path = File.join(intent_dir, "spec.md")
-    unless File.exist?(spec_path) && Bridge.stage_file_present?(spec_path)
-      return error_result("spec.md is missing or still the scaffold placeholder at #{spec_path}")
-    end
-
-    ac_body, ac_err = extract_acceptance_criteria(File.read(spec_path))
-    return error_result(ac_err) if ac_body.nil?
-
-    intent_file = Bridge.intent_file(intent_dir)
-    fm = IntentValidator.parse_frontmatter(intent_file)
-    intent_name = fm.is_a?(Hash) ? fm["intent"] : nil
-    if Bridge.blank?(intent_name)
-      return error_result("the intent file at #{intent_file} has no frontmatter intent name")
-    end
-
-    tdir = templates_dir || resolve_templates_dir(home: home)
-    return error_result(templates_missing_message(home: home)) if tdir.nil?
-
-    checklist_template_path = File.join(tdir, "checklist.md")
-    unless File.exist?(checklist_template_path)
-      return error_result("checklist.md template not found at #{checklist_template_path}")
-    end
-
-    template_text = File.read(checklist_template_path).sub("{{INTENT_NAME}}", intent_name)
-    written = replace_section_body(template_text, "## In Progress", [ac_body, "\n"])
-
-    FileUtils.mkdir_p(intent_dir)
-    File.write(target, written)
-    ok_result(target)
-  end
-
   # --- repo / base-branch resolution (shared with ACTION_3) -----------------------
 
   # The provisioned code worktree for this intent when it exists on disk, else the git
@@ -318,40 +185,7 @@ module ScaffoldIntent
     [res.stdout.to_s, nil]
   end
 
-  # --- outcome subcommand -----------------------------------------------------------
-
-  def scaffold_outcome(intent_dir:, force:, store:, id:, test_summary: nil,
-                       home: Dir.home, runner: Worktree::ShellRunner.new, templates_dir: nil)
-    target = File.join(intent_dir, "outcome.md")
-    return refuse_result(target) if refuse_without_force?(target, force)
-
-    intent_file = Bridge.intent_file(intent_dir)
-    return error_result("the intent file is missing at #{intent_file}") unless File.exist?(intent_file)
-
-    fm = IntentValidator.parse_frontmatter(intent_file)
-    intent_name = fm.is_a?(Hash) ? fm["intent"] : nil
-    if Bridge.blank?(intent_name)
-      return error_result("the intent file at #{intent_file} has no frontmatter intent name")
-    end
-
-    tdir = templates_dir || resolve_templates_dir(home: home)
-    return error_result(templates_missing_message(home: home)) if tdir.nil?
-
-    outcome_template_path = File.join(tdir, "outcome.md")
-    unless File.exist?(outcome_template_path)
-      return error_result("outcome.md template not found at #{outcome_template_path}")
-    end
-
-    verification_body = build_verification_body(store: store, id: id, intent_dir: intent_dir,
-                                                 home: home, runner: runner, test_summary: test_summary)
-
-    content = File.read(outcome_template_path).sub("# Outcome: <intent name>", "# Outcome: #{intent_name}")
-    written = replace_section_body(content, "## Verification", [verification_body, "\n"])
-
-    FileUtils.mkdir_p(intent_dir)
-    File.write(target, written)
-    ok_result(target)
-  end
+  # --- verification body (diffstat plus an optional test summary) ----------------------
 
   def build_verification_body(store:, id:, intent_dir:, home:, runner:, test_summary:)
     repo = resolve_repo_dir(store: store, id: id, intent_dir: intent_dir, home: home, runner: runner)