@zalom/plastic 2.0.0-alpha.9 → 2.0.2

package/scripts/end-intent

@@ -37,7 +37,7 @@
 #   2. Move the intent's INDEX.md line from `## Active` into `## Completed`
 #      (delivered) or `## Abandoned` (abandoned), dated today, appending
 #      --index-note (if given). Accepts a real em dash OR a plain hyphen as
-#      the id/title separator on READ (shared matcher, Bridge.index_entry_match);
+#      the id/title separator on READ (shared matcher, IndexEntry.match);
 #      always EMITS the real em dash on write. An id that resolves to neither
 #      `## Active` nor the terminal section is a loud failure (exit 1); an id
 #      already correctly in the terminal section is a quiet, idempotent success.
@@ -46,10 +46,13 @@
 #   5. Disarm (intent 188, D2/D16; intent 307): check the code worktree (derived
 #      from projects.yml and the intent id, Arm.worktree_block) for uncommitted
 #      changes first (exit 5 if dirty, unless --discard-worktree-changes); call the
-#      disarm seam (default Arm.disarm: worktree released, lock cleared, the session
-#      pointer back on the day ledger); verify the durable lock file is actually gone
-#      afterward, and release it directly when a foreign-keyed disarm left it (the
-#      /tmp bridge this step once read was removed in 2.0, intent 307).
+#      disarm seam (default Arm.disarm: worktree released, lock cleared); verify
+#      the durable lock file is actually gone afterward, and release it directly
+#      when a foreign-keyed disarm left it.
+#
+# A delivered close never merges code. Its code branch must already be merged
+# into the repo checkout's current branch, or the close refuses before any
+# write (exit 9).
 #
 # Exit codes:
 #   0  ok - the intent is closed and no delivery.lock remains.
@@ -57,7 +60,7 @@
 #      nor the terminal section (D11). Deliberately double duty; see plan.md.
 #   2  retired in 2.0 (intent 308): the outcome.md guard reports and proceeds.
 #   3  steps 1-4 already committed, but the delivery lock genuinely could not
-#      be cleared (not a bridge cache miss; see step 5 above).
+#      be cleared (see step 5 above).
 #   4  pre-flight refusal: a FRESH foreign lock is held by a live,
 #      non-delegate session; a FRESH lock that will not parse (corrupt); or a
 #      lock file with no resolvable session identity at all. Authors nothing.
@@ -68,19 +71,37 @@
 #   6  retired in 2.0 (intent 308): the structure check reports and proceeds.
 #   7  hollow delivered report refused (317a D7) - intent 308's one deliberate
 #      exception to report-and-proceed; --allow-hollow-report overrides.
+#   8  delivered close of an untouched scaffold refused (acceptance N3):
+#      nothing was worked, so there is nothing to deliver. Close it as
+#      abandoned, or do the work first. Authors nothing.
+#   9  delivered close refused because its code branch is not merged into the
+#      repo checkout's current branch. Refused before any write: nothing is
+#      merged, written, or released. Merge the branch, then run the close again.
+#
+# --dry-run runs the same refusals as the real close (exits 8, 9, 7 and 5 with
+# a "would refuse" line) and writes nothing: the hollow-report gate is judged
+# on a scratch copy that went through the same outcome generation and
+# backfill.
 
+require_relative "lib/store_layout"
 require "fileutils"
 require "date"
 require "open3"
+require "stringio"
+require "tmpdir"
 require "pathname"
-require_relative "lib/bridge"
 require_relative "lib/arm"
+require_relative "lib/exec_worktree"
+require_relative "lib/index_entry"
 require_relative "lib/savepoint"
 require_relative "lib/lock"
 require_relative "lib/intent_validator"
 require_relative "lib/outcome_guard"
 require_relative "lib/report_screen"
 require_relative "lib/backfill_intent"
+require_relative "lib/outcome_report"
+require_relative "lib/untouched_scaffold"
+require_relative "lib/scaffold_intent"
 
 DISPOSITIONS = %w[delivered abandoned].freeze
 
@@ -88,7 +109,7 @@ DISPOSITIONS = %w[delivered abandoned].freeze
 # 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.
-# READING accepts a plain hyphen too, via the shared Bridge.index_entry_match
+# READING accepts a plain hyphen too, via the shared IndexEntry.match
 # (intent 188, D9/D12): see move_index_to_terminal below.
 EM_DASH = "\u2014"
 
@@ -98,6 +119,10 @@ class UnresolvedIndexEntry < StandardError; end
 
 # --- Explicit flag parsing (no eval, no global injection) -------------------
 
+def blank?(value)
+  value.nil? || value.to_s.strip.empty?
+end
+
 def parse_args(argv)
   opts = {
     store: nil, id: nil, disposition: nil, index: nil,
@@ -166,14 +191,65 @@ end
 # "projects" (the StoreDiscovery convention, scripts/lib/store_discovery.rb), never by
 # hardcoding ".plastic" as a name.
 def resolve_plastic_home_and_scope(store)
-  parent = File.dirname(store)
-  grandparent = File.dirname(parent)
-  if File.basename(grandparent) == "projects"
-    slug = File.basename(parent)
-    [File.dirname(grandparent), "project:#{slug}"]
+  Plastic::StoreLayout.home_and_scope(store)
+end
+
+# --- outcome generation, before the backfill (intent 339, G6, spec D10) -----
+#
+# Generates outcome.md from graph.md, nodes/, and the ledger, BEFORE the
+# backfill step runs, and only into a file that is missing or still the
+# scaffold placeholder (`Savepoint.stage_file_present?` false) - a real,
+# hand-written outcome.md is never touched (row 7.2). Only when a graph.md
+# exists at all (row 7.3): every intent without one closes exactly as it did
+# before this intent. The model is parsed AFTER the `stage_file_present?`
+# guard, not before: a real hand-written outcome.md returns at that guard
+# regardless of graph.md's own health, so a close that was never going to
+# generate anything must never print a parse warning about it. Refuses a
+# report model that reports itself broken (row v1f.2, B2): a malformed
+# `## Graph` fails `model[:ok]` and the close falls straight through to the
+# backfill, rather than adopting parse damage as delivery fact - agreeing
+# with the shipped `outcome-report` CLI, which exits 3 on the same
+# directory. The generated text is then checked against
+# BOTH close gates - `OutcomeGuard` and the hollow-report gate below - before
+# being adopted (row 7.4); when either would refuse it, the write is
+# reverted and the close falls through to intent 308's unchanged backfill
+# (row 7.5), so no close gains an exit 7 it did not have before this intent.
+# Fails open on any exception (row 7.6), the same report-and-proceed shape
+# every other close step in this file uses. `generator:` is the injectable
+# seam (mirrors run_structure_check's `gate:`).
+def run_generate_outcome(intent_dir, disposition:, generator: OutcomeReport.method(:write))
+  graph_path = File.join(intent_dir, "graph.md")
+  return unless File.exist?(graph_path)
+
+  outcome_path = File.join(intent_dir, "outcome.md")
+  return if Savepoint.stage_file_present?(outcome_path)
+
+  report_model = OutcomeReport.model(intent_dir)
+  unless report_model[:ok]
+    warn "end-intent: graph.md failed to parse (#{report_model[:errors].join('; ')}); falling back to the backfill"
+    return
+  end
+
+  original_exists = File.exist?(outcome_path)
+  original_content = original_exists ? File.read(outcome_path) : nil
+
+  generator.call(intent_dir, disposition: disposition)
+
+  guard_reason = OutcomeGuard.reason(intent_dir, disposition)
+  hollow = hollow_report_reason(intent_dir, disposition)
+  if guard_reason || hollow
+    if original_exists
+      File.write(outcome_path, original_content)
+    elsif File.exist?(outcome_path)
+      File.delete(outcome_path)
+    end
+    warn "end-intent: generated outcome.md would be refused (#{[guard_reason, hollow].compact.join('; ')}); " \
+         "falling back to the backfill"
   else
-    [parent, "global"]
+    warn "end-intent: outcome.md generated from graph.md and the ledger"
   end
+rescue StandardError => e
+  warn "end-intent: outcome generation crashed (#{e.message}); proceeding without it"
 end
 
 # Backfill (intent 308): write the judgment documents that are missing or still the
@@ -227,6 +303,48 @@ end
 # closed exactly this way and the owner read a screen full of "not recorded".
 # Abandoned closes and machine-backfilled outcomes (the backfill marker) are
 # exempt: the reader cannot expect labels the writer never had.
+#
+# Intent 334 (G1, review A3; post-execution review, blocking 2): the legacy
+# "S3" label grammar applies only to actions/*.md headings, and the node id
+# grammar (kind prefix n/v/d/r plus digits, D1r) applies only to nodes/*.md
+# headings - never both over both directories. This repo's own house words
+# for plan review and post-execution review are "v1" and "v2"; widening the
+# node-id alternative onto actions/ headings turned that prose into a
+# manufactured label and refused legitimate legacy closes at exit 7.
+ACTION_ID_LABEL_RE = /\AS\d+\z/.freeze
+NODE_ID_LABEL_RE = /\A[nvdr][1-9]\d*\z/.freeze
+
+# The id-shaped tokens found in `paths`' headings, matched against
+# `id_label_re` only - the caller picks the grammar for the directory.
+def heading_id_labels(paths, id_label_re)
+  paths.flat_map do |path|
+    ReportScreen.split_by_headings(File.read(path)).flat_map do |heading, _body|
+      heading.to_s.sub(/\A#+\s*/, "").split(/[^A-Za-z0-9]+/).select { |tok| tok.match?(id_label_re) }
+    end
+  end
+end
+
+# 339 S9 (D18): a node id counts as a label in an actions/*.md heading too,
+# but only when it stands alone as one of the heading's " - "-delimited
+# segments - this repo's own convention, "### S1 - n1 - Title" (this action
+# file's own headings, post-merge) or the bare "### n1 - Title". Never as a
+# free word inside ordinary prose: the comment above ACTION_ID_LABEL_RE
+# records exactly why intent 334 restricted the node-id grammar to
+# nodes/*.md headings in the first place, and that reasoning does not change
+# here - a word-scan widened onto actions/ headings would let this repo's own
+# house words ("v1", "v2" for plan review and post-execution review)
+# manufacture a label out of ordinary prose and refuse a legitimate legacy
+# close. Segment position is what a word-scan cannot see: "v2" embedded
+# mid-sentence is never its own " - "-delimited segment, but a heading built
+# to this convention always puts the node id in one.
+def heading_node_id_segments(paths, id_label_re)
+  paths.flat_map do |path|
+    ReportScreen.split_by_headings(File.read(path)).flat_map do |heading, _body|
+      heading.to_s.sub(/\A#+\s*/, "").split(/\s+-\s+/).map(&:strip).select { |seg| seg.match?(id_label_re) }
+    end
+  end
+end
+
 def hollow_report_reason(intent_dir, disposition)
   return nil unless disposition == "delivered"
 
@@ -235,14 +353,34 @@ def hollow_report_reason(intent_dir, disposition)
   text = File.read(outcome)
   return nil if text.include?("<!-- backfilled from the record by end-intent on ")
 
-  # The gate's evidence bar (A7/B7): it judges only records that CLAIM the
-  # modern convention - at least one actions/*.md heading carrying an S-label.
-  # A terse legacy close with no labeled matrix stays report-and-proceed.
-  heading_labels = Dir.glob(File.join(intent_dir, "actions", "*.md")).sort.flat_map do |path|
-    ReportScreen.split_by_headings(File.read(path)).filter_map do |heading, _body|
-      heading.to_s.sub(/\A#+\s*/, "").split(/[^A-Za-z0-9]+/).find { |tok| tok.match?(/\AS\d+\z/) }
-    end
-  end.uniq
+  # The gate's evidence bar (A7/B7): it judges only records that CLAIM a
+  # labeled convention - at least one actions/*.md heading carrying an
+  # S-label or a node-id segment, or at least one nodes/*.md heading carrying
+  # a node id ("n1", "v2", "d3", "r4"). A terse legacy close with no labeled
+  # matrix stays report-and-proceed (intent 334, G1, D10r).
+  #
+  # Every matching token per heading is kept, not just the first (review A3):
+  # a legacy actions/ heading can carry BOTH an S-label and prose that reads
+  # like a node id ("### The v2 rewrite (S3)"). Restricting the word-scan
+  # node-id grammar to nodes/*.md headings (post-execution review, blocking
+  # 2) means "v2" in that heading is never even tested against it, so the
+  # heading's real "S3" label is never at risk.
+  #
+  # 339 S9 (D18): a graph-era action file headed by node id alone ("### n1 -
+  # Title", no S-label) used to yield an empty label set here and the gate
+  # returned before judging anything - every such record closed unjudged by
+  # silent exemption. `heading_node_id_segments` widens the actions/*.md side
+  # to see that shape without reopening the word-scan hole above: it matches
+  # a node id only when the heading's own " - "-delimited segments carry one,
+  # never a free word in prose. The node_paths call stays exactly as it was;
+  # nodes/*.md headings already resolve node ids correctly (test_node_id_
+  # labels_are_recognized) and their heading grammar is controlled, so a
+  # word-scan there carries none of the prose risk.
+  action_paths = Dir.glob(File.join(intent_dir, "actions", "*.md")).sort
+  node_paths = Dir.glob(File.join(intent_dir, "nodes", "*.md")).sort
+  heading_labels = (heading_id_labels(action_paths, ACTION_ID_LABEL_RE) +
+                     heading_node_id_segments(action_paths, NODE_ID_LABEL_RE) +
+                     heading_id_labels(node_paths, NODE_ID_LABEL_RE)).uniq
   return nil if heading_labels.empty?
 
   rows = ReportScreen.delivered_rows(intent_dir)
@@ -317,10 +455,10 @@ def section_stop(lines, heading_idx)
   stop
 end
 
-# Shared matcher (Bridge.index_entry_match, intent 188 D12): accepts a real em
+# Shared matcher (IndexEntry.match, intent 188 D12): accepts a real em
 # dash OR a plain hyphen as the id/title separator on READ.
 def active_line_id(line)
-  m = Bridge.index_entry_match(line)
+  m = IndexEntry.match(line)
   m && m[1]
 end
 
@@ -399,7 +537,7 @@ def move_index_to_terminal(content, id, disposition, today:, index_note: nil)
     raise UnresolvedIndexEntry, "INDEX.md has no #{target_heading} heading; cannot complete the move"
   end
 
-  m = Bridge.index_entry_match(lines[entry_idx])
+  m = IndexEntry.match(lines[entry_idx])
   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"
@@ -488,13 +626,13 @@ end
 # exclusion with a raw backtrace. nil is the only safe "could not resolve"
 # signal; main refuses explicitly on it rather than ever reaching takeover.
 def resolve_end_session(explicit, intent_dir)
-  return explicit.to_s.strip unless Bridge.blank?(explicit)
+  return explicit.to_s.strip unless blank?(explicit)
   env = ENV["CLAUDE_CODE_SESSION_ID"]
-  return env.to_s.strip unless Bridge.blank?(env)
+  return env.to_s.strip unless blank?(env)
   lock = Lock.read(intent_dir)
   return nil unless lock
   owner = lock["owner_session"].to_s
-  Bridge.blank?(owner) ? nil : owner
+  blank?(owner) ? nil : owner
 end
 
 # Read-only pre-flight verdict (D4). Returns [:proceed, lock_or_nil],
@@ -542,37 +680,15 @@ end
 def run_disarm(intent_dir, id, session, discard_worktree_changes:,
                worktree_reader: ->(dir) { Arm.worktree_block(intent_dir: dir) },
                disarm: ->(sess, dir) { Arm.disarm(intent_dir: dir, session: sess) })
-  return :ok if Bridge.blank?(session)
+  return :ok if blank?(session)
 
   block = worktree_reader.call(intent_dir)
   worktree_code = block.is_a?(Hash) ? block["code"] : nil
 
-  if worktree_code && Dir.exist?(worktree_code)
-    begin
-      out, err, status = Open3.capture3("git", "-C", worktree_code, "status", "--porcelain")
-    rescue StandardError => e
-      out, err, status = nil, e.message, nil
-    end
-
-    # Fail CLOSED (intent 188, post-review hardening). A failed or impossible
-    # `git status` (corrupt per-worktree index, git missing from PATH, not a
-    # repo) means we cannot PROVE the worktree is clean, and the removal below
-    # force-removes on a plain `git worktree remove` failure, which destroys
-    # uncommitted work. Never force-remove an unproven worktree: the guard
-    # exists to protect uncommitted code, so an inconclusive check must refuse,
-    # not silently proceed as if it were clean.
-    if status.nil? || !status.success?
-      unless discard_worktree_changes
-        warn "end-intent: could not inspect the code worktree at #{worktree_code} " \
-             "(git status failed: #{err.to_s.strip}); refusing to remove it, because " \
-             "removal would force-discard any uncommitted work. Pass " \
-             "--discard-worktree-changes to remove it anyway, or repair the worktree."
-        return :dirty
-      end
-    elsif !out.strip.empty? && !discard_worktree_changes
-      warn "end-intent: code worktree #{worktree_code} has uncommitted changes; refusing " \
-           "to remove it. Pass --discard-worktree-changes to force the close deliberately, " \
-           "or commit/stash the changes and re-run."
+  unless discard_worktree_changes
+    refusal = worktree_refusal(worktree_code)
+    if refusal
+      warn refusal
       return :dirty
     end
   end
@@ -640,6 +756,173 @@ def run_disarm(intent_dir, id, session, discard_worktree_changes:,
   :lock_remains
 end
 
+# The disarm step's dirty-worktree guard, as a message (nil when the worktree
+# is clean or absent). Shared by run_disarm and --dry-run so the preview
+# refuses exactly what the close refuses.
+#
+# Fail CLOSED (intent 188, post-review hardening). A failed or impossible
+# `git status` (corrupt per-worktree index, git missing from PATH, not a
+# repo) means we cannot PROVE the worktree is clean, and the removal
+# force-removes on a plain `git worktree remove` failure, which destroys
+# uncommitted work. Never force-remove an unproven worktree: the guard
+# exists to protect uncommitted code, so an inconclusive check must refuse,
+# not silently proceed as if it were clean.
+def worktree_refusal(worktree_code)
+  return nil unless worktree_code && Dir.exist?(worktree_code)
+
+  begin
+    out, err, status = Open3.capture3("git", "-C", worktree_code, "status", "--porcelain")
+  rescue StandardError => e
+    out, err, status = nil, e.message, nil
+  end
+
+  if status.nil? || !status.success?
+    "end-intent: could not inspect the code worktree at #{worktree_code} " \
+      "(git status failed: #{err.to_s.strip}); refusing to remove it, because " \
+      "removal would force-discard any uncommitted work. Pass " \
+      "--discard-worktree-changes to remove it anyway, or repair the worktree."
+  elsif !out.strip.empty?
+    "end-intent: code worktree #{worktree_code} has uncommitted changes; refusing " \
+      "to remove it. Pass --discard-worktree-changes to force the close deliberately, " \
+      "or commit/stash the changes and re-run."
+  end
+end
+
+# True when the intent's code worktree carries any work: uncommitted changes
+# or commits past its base branch. Anything that cannot be proven reads as
+# changed, so an unreadable worktree never turns a close into a refusal.
+def worktree_changed?(intent_dir)
+  block = Arm.worktree_block(intent_dir: intent_dir)
+  code = block.is_a?(Hash) ? block["code"] : nil
+  return false unless code && Dir.exist?(code)
+
+  out, status = Open3.capture2e("git", "-C", code, "status", "--porcelain")
+  return true unless status.success? && out.strip.empty?
+
+  base = ScaffoldIntent.detect_base_branch(code)
+  return true if base.nil?
+
+  ahead, status = Open3.capture2e("git", "-C", code, "rev-list", "--count", "#{base}..HEAD")
+  !status.success? || ahead.strip != "0"
+rescue StandardError
+  true
+end
+
+# A delivered close whose code is not on the repo checkout's current branch,
+# as a refusal message (nil when it is, or for a store-only project).
+# end-intent never merges: the owner merges or releases the work, then runs
+# the close again. A real code worktree must prove that its HEAD commit is
+# merged, so a detached or renamed branch is still checked. The code branch
+# must be merged too, even after its worktree is gone. A git failure refuses.
+# A directory that is not a working git worktree, with no code branch, is left
+# to the dirty-worktree guard, which refuses what it cannot inspect.
+def unmerged_refusal(intent_dir, runner: Worktree::ShellRunner.new)
+  paths = Arm.code_paths(intent_dir: intent_dir)
+  code = paths["code"]
+  return nil if code.nil?
+
+  repo = ExecWorktree.repo_from_worktree_code(code)
+  unless runner.run("-C", repo, "rev-parse", "--git-dir").success?
+    # No .git at all is a project without code; a .git that Git cannot read is not.
+    return nil unless File.exist?(File.join(repo, ".git"))
+
+    return "could not inspect the Git repository #{repo}, so the code cannot be shown to be merged. " \
+      "Check the repository, then run the close again"
+  end
+
+  unmerged_worktree_head(runner, code, repo, paths["code_branch"]) ||
+    unmerged_branch(runner, repo, paths["code_branch"])
+end
+
+# True when `code` is the top of its own git work tree, not a plain
+# directory inside the repo or a broken checkout.
+def real_worktree?(runner, code)
+  return false unless File.directory?(code)
+
+  top = runner.run("-C", code, "rev-parse", "--show-toplevel")
+  top.success? && File.realpath(top.stdout.strip) == File.realpath(code)
+rescue SystemCallError
+  false
+end
+
+def unmerged_worktree_head(runner, code, repo, branch)
+  return nil unless real_worktree?(runner, code)
+
+  head = runner.run("-C", code, "rev-parse", "--verify", "--quiet", "HEAD^{commit}")
+  unless head.success?
+    return "could not read the HEAD commit of the code worktree #{code}, so its work cannot be " \
+      "shown to be merged. Commit it, merge it into the current branch of #{repo}, then run the close again"
+  end
+  sha = head.stdout.strip
+  on = runner.run("-C", code, "symbolic-ref", "--quiet", "--short", "HEAD")
+  name = on.success? ? on.stdout.strip : nil
+  ref = (name == branch) ? branch : sha[0, 12]
+  where = name ? "on branch #{name}" : "detached"
+  ancestry_refusal(runner, repo, sha, ref, "the code worktree #{code} (#{where} at #{sha[0, 12]})", branch)
+end
+
+def unmerged_branch(runner, repo, branch)
+  found = runner.run("-C", repo, "show-ref", "--verify", "--quiet", "refs/heads/#{branch}")
+  return nil if found.status == 1
+  unless found.success?
+    return "could not look up code branch #{branch} in #{repo}. Check the repository, then run the close again"
+  end
+  ancestry_refusal(runner, repo, branch, branch, "code branch #{branch}", branch)
+end
+
+# nil when `rev` is an ancestor of the branch the repo checkout is on, else a
+# refusal naming `what` and the ordinary merge of `ref` that fixes it.
+def ancestry_refusal(runner, repo, rev, ref, what, branch)
+  target = target_refusal(runner, repo, branch)
+  return target if target
+
+  check = runner.run("-C", repo, "merge-base", "--is-ancestor", rev, "HEAD")
+  return nil if check.success?
+
+  verdict = (check.status == 1) ? "is not merged into" : "could not be checked against"
+  "#{what} #{verdict} the current branch of #{repo}. " \
+    "Merge it there first (git -C #{repo} merge #{ref}), then run the close again"
+end
+
+# Integration means merged into a branch other than the code branch, so a
+# detached checkout, or one on the code branch itself, proves nothing.
+def target_refusal(runner, repo, branch)
+  on = runner.run("-C", repo, "symbolic-ref", "--quiet", "--short", "HEAD")
+  unless on.success?
+    return "the repo checkout #{repo} is not on a branch, so no branch holds the merged code. " \
+      "Check out the branch you release from, merge #{branch} into it, then run the close again"
+  end
+  return nil unless on.stdout.strip == branch
+
+  "the repo checkout #{repo} is on the code branch #{branch} itself, so the code is not merged anywhere. " \
+    "Check out the branch you release from, merge #{branch} into it, then run the close again"
+end
+
+# The hollow-report verdict the real close would reach, judged on a scratch
+# copy of the intent after the same outcome generation and backfill, so the
+# dry run writes nothing.
+def predicted_hollow_reason(intent_dir, store:, id:, disposition:, summary:)
+  return nil unless disposition == "delivered"
+
+  Dir.mktmpdir("end-intent-dry-run") do |scratch|
+    copy = File.join(scratch, File.basename(intent_dir))
+    FileUtils.cp_r(intent_dir, copy)
+    quietly do
+      run_generate_outcome(copy, disposition: disposition)
+      run_backfill(copy, store: store, id: id, disposition: disposition, summary: summary)
+    end
+    hollow_report_reason(copy, disposition)
+  end
+end
+
+def quietly
+  saved = $stderr
+  $stderr = StringIO.new
+  yield
+ensure
+  $stderr = saved
+end
+
 # --- main --------------------------------------------------------------------
 
 def main(argv)
@@ -667,7 +950,7 @@ def main(argv)
   # Lock.takeover (blank session reaches Lock.acquire's blank? guard AFTER the
   # existing lock file was already deleted) or silently mis-arbitrate. Refuse
   # rather than guess; nothing has been written yet.
-  if Bridge.blank?(session) && File.exist?(Lock.path(intent_dir))
+  if blank?(session) && File.exist?(Lock.path(intent_dir))
     warn "end-intent: a delivery lock exists at #{Lock.path(intent_dir)} but no session " \
          "identity could be resolved (--session, CLAUDE_CODE_SESSION_ID, and the lock's " \
          "own recorded owner are all blank); refusing rather than guessing. Pass " \
@@ -692,7 +975,41 @@ def main(argv)
     exit 4
   end
 
+  # Nothing worked, nothing to deliver (acceptance N3). Before the dry run and
+  # before any write, so the preview and the close refuse together.
+  if disposition == "delivered"
+    untouched = UntouchedScaffold.reason(intent_dir, templates: BackfillIntent.load_templates,
+                                                     worktree_changed: method(:worktree_changed?))
+    if untouched
+      warn "end-intent: refusing to deliver an untouched scaffold: #{untouched}"
+      warn "end-intent: do the work first, or close it with --disposition abandoned"
+      exit 8
+    end
+
+    unmerged = unmerged_refusal(intent_dir)
+    if unmerged
+      warn "end-intent: #{opts[:dry_run] ? "dry run: would refuse" : "refusing"} a delivered close: #{unmerged}"
+      warn "end-intent: nothing was merged, written, or released"
+      exit 9
+    end
+  end
+
   if opts[:dry_run]
+    hollow = predicted_hollow_reason(intent_dir, store: store, id: id, disposition: disposition,
+                                                 summary: opts[:outcome_summary])
+    if hollow && !opts[:allow_hollow_report]
+      warn "end-intent: dry run: would refuse a hollow delivered close: #{hollow}"
+      exit 7
+    end
+    unless blank?(session) || opts[:discard_worktree_changes]
+      block = Arm.worktree_block(intent_dir: intent_dir)
+      refusal = worktree_refusal(block.is_a?(Hash) ? block["code"] : nil)
+      if refusal
+        warn "end-intent: dry run: would refuse at disarm (exit 5), after the store commit: " \
+             "#{refusal.delete_prefix("end-intent: ")}"
+        exit 5
+      end
+    end
     puts "end-intent: dry run for #{File.basename(intent_dir)} (#{disposition})"
     targets = BackfillIntent.targets_for(intent_dir)
     puts "  would backfill: #{targets.empty? ? "(nothing)" : targets.join(", ")}"
@@ -718,6 +1035,11 @@ def main(argv)
     end
   end
 
+  # 0a. Generate outcome.md from graph.md and the ledger, when there is one
+  # (intent 339, G6, spec D10) - before the backfill, so a real graph never
+  # falls through to the terse backfill it exists to replace.
+  run_generate_outcome(intent_dir, disposition: disposition)
+
   # 1. Backfill from the record (intent 308), then the structure self-check and the
   # outcome guard, both report-only since 308.
   run_backfill(intent_dir, store: store, id: id, disposition: disposition,

package/scripts/exec-worktree

@@ -21,15 +21,15 @@
 #      (--session, else CLAUDE_CODE_SESSION_ID, else the existing delivery.lock's own
 #      recorded owner_session when non-blank, else nil; the lock-owner fallback IS
 #      used here, matching end-intent's teardown resolution order).
-#      Derive the worktree block from projects.yml and the intent id (Arm.worktree_block;
-#      the /tmp bridge this once read was removed in 2.0, intent 307). No code worktree on
+#      Derive the worktree block from projects.yml and the intent id (Arm.worktree_block).
+#      No code worktree on
 #      disk means nothing was provisioned (exit 0).
 #   1. The dirty-worktree guard (delivered only): git status --porcelain on the code
 #      worktree. Not clean, or the check itself fails, fails CLOSED (exit 3), mirroring
 #      end-intent's dirty-worktree handling. abandoned skips this guard entirely: the
 #      branch survives and can be reclaimed, so a dirty worktree is not a reason to
 #      refuse.
-#   2. Finish: Worktree.finish(bridge_data, home:, runner:, merge: disposition ==
+#   2. Finish: Worktree.finish(delivery, home:, runner:, merge: disposition ==
 #      "delivered"). Worktree.finish is fail-open and never raises, so failure is
 #      detected by checking, for a delivered disposition only, whether the worktree
 #      directory still exists on disk afterward (release removes it on success).
@@ -38,8 +38,8 @@
 # one concern per script (spec D8).
 #
 # Exit codes:
-#   0  finished (merged or removed per disposition), or nothing to finish (no bridge
-#      resolved, or no code worktree recorded on the bridge)
+#   0  finished (merged or removed per disposition), or nothing to finish (no delivery
+#      resolved, or no code worktree recorded on it)
 #   1  usage or path-resolution failure
 #   2  retired in 2.0 (intent 302): was the order precondition; never emitted, never reused
 #   3  the worktree is not clean, or the merge/removal did not complete (delivered only)

package/scripts/file-session-intent

@@ -14,6 +14,7 @@
 # and on any filing error (reported on stderr; the next boot tries again), 2 on
 # a usage error.
 
+require_relative "lib/store_layout"
 require_relative "lib/session_ledger"
 require_relative "lib/session_backfill"
 
@@ -48,7 +49,7 @@ if opts[:carry_to] && !SessionLedger.valid_day_id?(opts[:carry_to])
   usage_abort("--carry-to must be a real calendar date, YYYYMMDD")
 end
 
-store = opts[:store] || File.join(File.expand_path(ENV.fetch("PLASTIC_HOME", "~/.plastic")), "store")
+store = opts[:store] || Plastic::StoreLayout.global_store(File.expand_path(ENV.fetch("PLASTIC_HOME", "~/.plastic")))
 templates = opts[:templates] || File.expand_path("../templates", __dir__)
 
 begin