@zalom/plastic 2.0.0-alpha.7 → 2.0.0-alpha.9

package/hooks/message-display

@@ -49,8 +49,16 @@ if [ "$is_index_zero" = 1 ]; then
   # single "#", not "##" — a real screen's own first delta can be as short
   # as "## " — a "##" glob would filter out exactly the message this hook
   # exists to recognize.
+  # 317a (B11): a screen can open with "## " (state, delivered), a bare "▶"
+  # (roster), or a bare "✔" (delay); the JSON may carry the glyph raw or
+  # \u-escaped depending on the encoder. All globs are literal bytes - case
+  # matching is byte-wise, so multibyte literals are safe under bash 3.2.
   case $INPUT in
     *'"delta":"#'*|*'"delta": "#'*) handoff=1 ;;
+    *'"delta":"▶'*|*'"delta": "▶'*) handoff=1 ;;
+    *'"delta":"✔'*|*'"delta": "✔'*) handoff=1 ;;
+    *'"delta":"▶'*|*'"delta": "▶'*) handoff=1 ;;
+    *'"delta":"✔'*|*'"delta": "✔'*) handoff=1 ;;
   esac
 else
   # A later chunk: hand off when this message's directory already exists
@@ -62,7 +70,7 @@ else
   [ "$is_final" = 1 ] && handoff=1
   case $INPUT in
     *'"delta":"|'*|*'"delta": "|'*) handoff=1 ;;
-    *'"delta":"**Steps**'*|*'"delta": "**Steps**'*) handoff=1 ;;
+    *'"delta":"**'*|*'"delta": "**'*) handoff=1 ;;
     *'"delta":""'*|*'"delta": ""'*) handoff=1 ;;
     *'"delta":"\n"'*|*'"delta": "\n"'*) handoff=1 ;;
   esac

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalom/plastic",
-  "version": "2.0.0-alpha.7",
+  "version": "2.0.0-alpha.9",
   "description": "Intent-driven idea development system for AI coding agents",
   "type": "module",
   "bin": {

package/scripts/agent-report

@@ -22,6 +22,8 @@
 # Exit codes: 0 (report emitted), 2 (usage).
 
 require_relative "lib/savepoint"
+require_relative "lib/intent_screen"
+
 def parse_args(argv)
   role = nil
   positional = []
@@ -67,11 +69,15 @@ STAGE_LABELS = {
   "exec" => "Exec", "done" => "Done"
 }.freeze
 
+# Intent 317, D6: name the last LIFECYCLE line, never a trailing Lock/Review/
+# Commit line (same guard as spawn-preamble; plan review finding B1).
 def current_stage(intent_dir)
   ledger = File.join(intent_dir, Savepoint::SAVEPOINT_FILE)
   if File.exist?(ledger)
-    last = File.read(ledger).each_line.map(&:strip).reject(&:empty?).last
-    return last if last
+    lines = File.read(ledger).each_line.map(&:strip).reject(&:empty?)
+    lifecycle = lines.select { |l| IntentScreen.lifecycle_line?(l) }
+    return lifecycle.last if lifecycle.any?
+    return lines.last if lines.any?
   end
   STAGE_LABELS.fetch(Savepoint.derive_stage(intent_dir), Savepoint.derive_stage(intent_dir))
 end

package/scripts/end-intent

@@ -66,6 +66,8 @@
 #      refused before removal; pass --discard-worktree-changes to override
 #      deliberately.
 #   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.
 
 require "fileutils"
 require "date"
@@ -77,6 +79,7 @@ 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"
 
 DISPOSITIONS = %w[delivered abandoned].freeze
@@ -99,6 +102,7 @@ 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,
+    allow_hollow_report: false,
     session: nil, discard_worktree_changes: false,
   }
   i = 0
@@ -115,6 +119,7 @@ def parse_args(argv)
     when "--discard-worktree-changes" then opts[:discard_worktree_changes] = true
     when "--no-commit"                then opts[:no_commit] = true
     when "--dry-run"                  then opts[:dry_run] = true
+    when "--allow-hollow-report"      then opts[:allow_hollow_report] = true
     else
       usage_abort("unknown argument #{arg.inspect}")
     end
@@ -215,7 +220,75 @@ end
 # 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.
+# 317a S9 (D7): the self-render gate. Renders the delivered screen's sources on
+# the intent's own record and names what would come out hollow. This is intent
+# 308's ONE deliberate exception to report-and-proceed: a hollow DELIVERED
+# close is refused with exit 7 (--allow-hollow-report overrides), because 317
+# 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.
+def hollow_report_reason(intent_dir, disposition)
+  return nil unless disposition == "delivered"
+
+  outcome = File.join(intent_dir, "outcome.md")
+  return nil unless File.exist?(outcome)
+  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
+  return nil if heading_labels.empty?
+
+  rows = ReportScreen.delivered_rows(intent_dir)
+  return "outcome.md ## Delivered renders no rows although a labeled action matrix exists" if rows.empty?
+
+  needs = ReportScreen.section_of(text, "## Needs you").gsub(/<!--.*?-->/m, "").strip
+  if !needs.empty? && needs != "None" && ReportScreen.needs_you_rows(intent_dir).empty?
+    return "## Needs you has content that would render as None"
+  end
+
+  labels = rows.map { |r| r[:label] }
+  if (labels & heading_labels).empty?
+    return "delivered row labels (#{labels.first(3).join(', ')}...) match no action-file heading (#{heading_labels.first(3).join(', ')}...)"
+  end
+  if rows.all? { |r| ReportScreen.proven_by(intent_dir, r[:label]) == ReportScreen::NOT_RECORDED }
+    return "every Proven-by cell renders not recorded although labeled action headings exist"
+  end
+
+  nil
+rescue StandardError => e
+  warn "end-intent: hollow-report gate crashed (#{e.message}); proceeding without it"
+  nil
+end
+
+# 317a S7 (D5, A8): stamp the live lock's run_mode into outcome.md frontmatter
+# INSIDE the close step - after the gate, before the INDEX move and the store
+# commit - so the stamped file rides the close commit and mode survives disarm.
+def stamp_outcome_mode(intent_dir)
+  data = Lock.read(intent_dir)
+  run_mode = data && data["run_mode"].to_s
+  return if run_mode.nil? || run_mode.empty?
+
+  path = File.join(intent_dir, "outcome.md")
+  return unless File.exist?(path)
+  text = File.read(path)
+  return unless text.start_with?("---")
+  head, body = text[3..].split("---", 2)
+  return if body.nil? || head.match?(/^mode:/)
+
+  File.write(path, "---#{head}mode: #{run_mode}\n---#{body}")
+rescue StandardError => e
+  warn "end-intent: mode stamp failed (#{e.message}); proceeding without it"
+end
+
 def stamp_outcome_summary(content, summary)
+
   return content if summary.nil? || summary.to_s.strip.empty?
 
   lines = content.lines
@@ -654,6 +727,26 @@ def main(argv)
   reason = OutcomeGuard.reason(intent_dir, disposition)
   warn "end-intent: outcome.md: #{reason} (proceeding; doctor --intent #{id} reports it)" if reason
 
+  # 1a2. The self-render gate (317a S9, D7): refuse a hollow delivered close
+  # BEFORE any terminal mutation - INDEX, savepoint, and store stay untouched
+  # on exit 7 (A9).
+  hollow = hollow_report_reason(intent_dir, disposition)
+  if hollow
+    if opts[:allow_hollow_report]
+      warn "end-intent: hollow delivered report overridden (--allow-hollow-report): #{hollow}"
+    else
+      warn "end-intent: refusing a hollow delivered close: #{hollow}"
+      warn "end-intent: write outcome.md's ## Delivered as the labeled | Row | What | table " \
+           "matching the action-file headings (templates/outcome.md shows the shape), " \
+           "or pass --allow-hollow-report to close anyway"
+      exit 7
+    end
+  end
+
+  # 1a3. Mode stamp (317a S7, D5): run_mode into outcome frontmatter while the
+  # lock still exists, so the stamped file rides the close commit.
+  stamp_outcome_mode(intent_dir)
+
   # 1b. Intent-file `## Outcome` summary stamp (no-op unless given).
   if opts[:outcome_summary]
     intent_file = Savepoint.intent_file(intent_dir)

package/scripts/hook-message-display

@@ -15,11 +15,18 @@
 #
 # Claude adapter: Claude Code only; the core is harness-agnostic.
 
-require "json"
-require "time"
-require "tmpdir"
-require "yaml"
-require_relative "lib/message_display"
+# 317a (B1): the requires sit inside their own rescue - a missing or broken
+# lib file must never surface as a non-zero exit or stderr on a chunk of an
+# ordinary message (LoadError is a ScriptError, outside StandardError).
+begin
+  require "json"
+  require "time"
+  require "tmpdir"
+  require "yaml"
+  require_relative "lib/message_display"
+rescue ScriptError, StandardError
+  exit 0
+end
 
 def color_enabled?(plastic_home)
   return false unless ENV["NO_COLOR"].to_s.empty?

package/scripts/lib/day_summary.rb

@@ -12,6 +12,7 @@ require "time"
 require_relative "session_ledger"
 require_relative "handoff"
 require_relative "lock"
+require_relative "report_screen"
 
 module DaySummary
   module_function
@@ -113,8 +114,12 @@ module DaySummary
         dir = File.join(store_dir, dirname)
         next unless File.directory?(dir) && Lock.fresh?(dir, now: now)
         # A guided session's lock is live but not autonomous; a lock with no
-        # run_mode (a 1.14 auto team) counts as auto.
-        next if (Lock.read(dir) || {})["run_mode"].to_s == "guided"
+        # run_mode (a 1.14 auto team) counts as auto. 317a (B9): when the lock
+        # carries no run_mode, the outcome frontmatter stamp (D5) is asked
+        # before defaulting, so a guided close never reads as auto.
+        run_mode = (Lock.read(dir) || {})["run_mode"].to_s
+        run_mode = ReportScreen.outcome_frontmatter(dir)["mode"].to_s if run_mode.empty?
+        next if run_mode == "guided"
 
         id, slug = dirname.split("--", 2)
         "- #{id} #{slug}: #{last_savepoint_line(dir)}"

package/scripts/lib/installer_core.rb

@@ -400,6 +400,9 @@ class InstallerCore
       "scripts/lib/harness_text.rb" => "scripts/lib/harness_text.rb",
       "scripts/codex-hook" => "scripts/codex-hook",
       "scripts/spawn-preamble" => "scripts/spawn-preamble",
+      "scripts/lib/report_screen.rb" => "scripts/lib/report_screen.rb",
+      "scripts/report-screen" => "scripts/report-screen",
+      "scripts/savepoint-note" => "scripts/savepoint-note",
       "scripts/lib/store_provisioning.rb" => "scripts/lib/store_provisioning.rb",
       "scripts/provision-project-store" => "scripts/provision-project-store",
       "scripts/lib/project_validator.rb" => "scripts/lib/project_validator.rb",
@@ -449,6 +452,7 @@ class InstallerCore
       # entries are their only protection (test/install_sync_test.rb:23-29
       # greps installer_core.rb's own source text for "scripts/<name>").
       "scripts/lib/intent_screen_ansi.rb" => "scripts/lib/intent_screen_ansi.rb",
+      "scripts/lib/screen_paint.rb" => "scripts/lib/screen_paint.rb",
       "scripts/lib/message_display.rb" => "scripts/lib/message_display.rb",
       "scripts/hook-message-display" => "scripts/hook-message-display",
     }

package/scripts/lib/intent_screen.rb

@@ -24,10 +24,26 @@ module IntentScreen
   # Em dash and en dash added (intent 316a O1e): a checklist item written
   # "S1 — text" (the em dash every checklist this intent writes, and the one a
   # reviewer reads, uses) kept its prefix under the old character class and
-  # rendered "S1  [ open ]  S1 — text" on screen.
-  STEP_PREFIX_RE = /\A(?:Step|S)\s*\d+\s*[-:·—–]\s*/i
+  # rendered "S1  [ open ]  S1 — text" on screen. Intent 317a (A1) made the
+  # separator optional with required whitespace: "S1 text" (the shape real
+  # checklists use) kept its label and doubled in next_fields; a bare "S1"
+  # has no following text and stays prose.
+  STEP_PREFIX_RE = /\A(?:Step|S)\s*\d+\s*(?:[-:·—–]\s*|\s+)(?=\S)/i
   INSIGHT_RE = /\A(\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ)\s+·\s+\S+\s+·\s+.+?\s+—\s+(.+)\z/
   SAVEPOINT_RE = /\A(\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ)\s{2,}(\S+)\s{2,}(.+?)\s*\z/
+  # Intent 317, D6: field-2 tokens that are genuine lifecycle stages. A ledger
+  # can also carry non-lifecycle lines (`Lock  takeover: ...`, and 317's own
+  # `Review`/`Commit`); those must never be mistaken for the current stage.
+  # Placed here, clear of STEP_PREFIX_RE above (316a edits that one).
+  LIFECYCLE_STAGES = %w[What Why How Exec Done].freeze
+
+  # True iff a raw savepoint ledger line's field 2 is a genuine lifecycle
+  # stage (post-execution-review finding 5: centralizes what spawn-preamble
+  # and agent-report used to each copy-paste beside the constant above).
+  def self.lifecycle_line?(line)
+    parts = line.to_s.split(/\s{2,}/)
+    parts.length >= 2 && LIFECYCLE_STAGES.include?(parts[1])
+  end
 
   # Word-boundary truncation caps (intent 316a D3/O1a/O1c). Never a clause
   # trim: a clause trim on step text destroys a pinned `OPEN:` row
@@ -126,14 +142,22 @@ module IntentScreen
   def self.savepoint_fields(intent_dir, intent_text)
     path = File.join(intent_dir, "savepoint.md")
     lines = File.exist?(path) ? File.readlines(path).map(&:strip).reject(&:empty?) : []
-    last = lines.reverse.map { |l| l.match(SAVEPOINT_RE) }.compact.first
+    matched = lines.reverse.map { |l| l.match(SAVEPOINT_RE) }.compact
+    last = matched.first
     unless last
       return { "stage" => "Why", "stage.note" => "no savepoint line yet",
                "savepoint" => "none", "savepoint.note" => "" }
     end
 
+    # D6: the STAGE PICK is guarded to the last LIFECYCLE line (What/Why/How/
+    # Exec/Done), so a trailing Lock/Review/Commit line cannot be mistaken for
+    # the stage. The Savepoint field below still shows the TRUE last line,
+    # whatever its kind - that is what a savepoint is.
+    lifecycle_last = matched.find { |m| LIFECYCLE_STAGES.include?(m[2]) }
+    stage_source = lifecycle_last || last
+
     ts, stage, milestone = last[1], last[2], last[3]
-    landing = landing_stage(stage, milestone)
+    landing = landing_stage(stage_source[2], stage_source[3])
     delivered = lines.map { |l| l.match(SAVEPOINT_RE) }.compact.map { |m| m[2] }.uniq
     delivered &= %w[What Why How Exec]
     note = if landing == "Done"

package/scripts/lib/message_display.rb

@@ -2,10 +2,7 @@
 # frozen_string_literal: true
 
 require "fileutils"
-require_relative "intent_screen"
-require_relative "intent_screen_ansi"
-require_relative "store_discovery"
-require_relative "store_provisioning"
+require_relative "screen_paint"
 
 # MessageDisplay (intent 316a, O4/O5, round 3 concurrency fix) - the Claude
 # Code MessageDisplay hook handler. One process per streamed chunk of every
@@ -50,7 +47,10 @@ require_relative "store_provisioning"
 # buffered original, never nil, never "") and D12 (color: false never
 # buffers or blanks anything) are unchanged.
 class MessageDisplay
-  MARKER_RE = /\A## ▶ (\S+) · /.freeze
+  # 317a (A4): engagement is grammar, not identity - any screen-family
+  # opener engages, with NO intent-id resolution (the roster and delay
+  # screens have none to resolve). ScreenPaint owns the full grammar.
+  ENGAGE_RE = /\A(?:##? )?[▶✔] /.freeze
   BUFFER_DIR_NAME = "plastic-message-display"
   BUFFER_MAX_AGE_SECONDS = 3600
   SCREEN_FILE = "SCREEN"
@@ -118,17 +118,14 @@ class MessageDisplay
   # resolve the id, both before anything is buffered or blanked (F4). Either
   # failure writes NOSCREEN so every later chunk can decide instantly rather
   # than waiting out its own budget for a decision that will never arrive.
-  def handle_chunk_zero(dir, delta, cwd, final)
+  def handle_chunk_zero(dir, delta, _cwd, final)
     stripped = delta.sub(/\A[ \t]+/, "")
-    m = stripped.match(MARKER_RE)
-    resolved = m && resolve_intent_dir(m[1], cwd)
-
-    unless resolved
+    unless ENGAGE_RE.match?(stripped)
       write_noscreen(dir)
       return nil
     end
 
-    write_screen(dir, resolved)
+    write_screen(dir)
     write_chunk(dir, 0, delta)
     final ? finalize_final(dir, 0) : ""
   end
@@ -177,7 +174,7 @@ class MessageDisplay
   # every ordinary prose message answers no, at zero cost.
   def maybe_screen?(delta)
     stripped = delta.lstrip
-    stripped.empty? || stripped.start_with?("|") || stripped.start_with?("**Steps**")
+    stripped.empty? || stripped.start_with?("|") || stripped.start_with?("**")
   end
 
   # The final chunk additionally waits (same budget) for every earlier chunk
@@ -190,8 +187,7 @@ class MessageDisplay
     buffered = nil
     begin
       buffered = read_buffered_chunks(dir, index)
-      decision = read_screen_decision(dir)
-      finalize(buffered, decision)
+      finalize(buffered, nil)
     rescue StandardError
       buffered
     ensure
@@ -226,28 +222,31 @@ class MessageDisplay
     end.join
   end
 
-  def read_screen_decision(dir)
-    content = File.read(File.join(dir, SCREEN_FILE))
-    intent_dir, store_root = content.split("\n")
-    { intent_dir: intent_dir, store_root: store_root }
-  end
+  # 317a (D1/B10): paint what was printed. The buffered message's screen
+  # region - located and bounded by ScreenPaint's own grammar - is re-laid in
+  # the ANSI vocabulary; prose before and after survives verbatim. A region
+  # the painter cannot parse returns the buffered original (A3: chunks were
+  # already blanked, so nil here would truncate the message to its final
+  # delta; nil is only for the never-engaged path in handle).
+  #
+  # markdown_safe: true (intent 316a1, D5) - Claude Code still Markdown-
+  # processes displayContent even inside a raw ANSI block, so the Claude
+  # adapter asks the harness-agnostic core to strip markdown noise. A harness
+  # whose display surface passes raw ANSI through untouched would ask for
+  # false instead.
+  def finalize(buffered, _decision)
+    lines = buffered.lines
+    start = lines.index { |l| ScreenPaint.classify(l) == :opener }
+    return buffered unless start
 
-  def finalize(buffered, decision)
-    intent_dir = decision[:intent_dir]
-    store_root = decision[:store_root]
-    # markdown_safe: true (intent 316a1, D5) - Claude Code still Markdown-
-    # processes displayContent even inside a raw ANSI block (316a's live
-    # capture showed backticks silently stripped from step text), so the
-    # Claude adapter asks the harness-agnostic core to strip markdown noise
-    # before it ever reaches the block. A harness whose display surface
-    # passes raw ANSI through untouched would ask for false instead.
-    ansi = IntentScreenAnsi.render(intent_dir: intent_dir, store_root: store_root, color: true, markdown_safe: true)
-    plain = IntentScreen.render(intent_dir: intent_dir, store_root: store_root, template: File.read(template_path))
-    splice(buffered, plain, ansi)
-  end
+    stop = ScreenPaint.region_end(lines, start)
+    painted = ScreenPaint.paint(lines[start...stop].join, color: true, markdown_safe: true)
+    return buffered unless painted
 
-  def template_path
-    File.expand_path("../../templates/intent-screen.md", __dir__)
+    suffix = lines[stop..].to_a.join.sub(/\A\n+/, "")
+    out = +"#{lines[0...start].join}#{painted.rstrip}\n"
+    out << "\n#{suffix}" unless suffix.empty?
+    out
   end
 
   def write_chunk(dir, index, delta)
@@ -257,8 +256,8 @@ class MessageDisplay
   # IntentScreen/IntentScreenAnsi's store_root: is the TIER root (what HOLDS
   # store/ — e.g. .../projects/<slug> or plastic_home itself), never the
   # store/ directory itself; resolve_intent_dir's `root:` is already that.
-  def write_screen(dir, resolved)
-    atomic_write(File.join(dir, SCREEN_FILE), "#{resolved[:intent_dir]}\n#{resolved[:root]}\n")
+  def write_screen(dir)
+    atomic_write(File.join(dir, SCREEN_FILE), "")
   end
 
   def write_noscreen(dir)
@@ -272,98 +271,7 @@ class MessageDisplay
     File.rename(tmp_path, path)
   end
 
-  # D16: replace the plain render's own text wherever it sits in the buffered
-  # message, keeping everything after it verbatim. Falls back to a line-based
-  # boundary (the "## ▶ " line through the last line starting with "|") only
-  # when the buffered text does not start with the plain render exactly (the
-  # model reformatted something, or a chunk gap broke the exact match) — the
-  # fallback also has to work for a checklist-less intent, whose only Steps
-  # row is "| | | no steps yet |".
-  def splice(buffered, plain, ansi)
-    suffix =
-      if buffered.start_with?(plain)
-        buffered[plain.length..]
-      else
-        line_based_suffix(buffered, plain)
-      end
-    return buffered if suffix.nil?
-
-    "#{ansi.rstrip}\n\n#{suffix}"
-  end
 
-  # Bounded fallback (matrix, lead's B1): walk forward from the "## ▶ " line
-  # only through the screen's OWN contiguous run of blank lines, "|"-prefixed
-  # table rows and the "**Steps**" heading, and stop at the first line that is
-  # none of those. The boundary is the last "|" line seen before that stop —
-  # never the last "|" line anywhere in the message. Scanning to the end
-  # unbounded (the old behavior) swallows any prose the model wrote between
-  # the screen and an unrelated Markdown table further down (a real hazard:
-  # Plastic replies carry tables often).
-  def line_based_suffix(buffered, plain)
-    lines = buffered.lines
-    start_idx = lines.index { |l| l.start_with?("## ▶ ") }
-    return nil unless start_idx
-
-    last_pipe_idx = nil
-    i = start_idx + 1
-    while i < lines.length
-      line = lines[i]
-      stripped = line.strip
-      break unless stripped.empty? || line.start_with?("|") || stripped == "**Steps**"
-
-      last_pipe_idx = i if line.start_with?("|")
-      i += 1
-    end
-    return nil unless last_pipe_idx
-
-    # Guard: never let the bounded scan consume more lines than the freshly
-    # rendered plain screen itself has. If it would, something about the
-    # buffered text does not match the shape splice() expects at all — pass
-    # the original through rather than risk eating real prose.
-    consumed = last_pipe_idx + 1 - start_idx
-    return nil if consumed > plain.lines.length
-
-    lines[(last_pipe_idx + 1)..].join
-  end
-
-  # O5: candidates are every discovered store holding a "<id>--*" directory.
-  # A single candidate resolves outright (no ambiguity to break). With two or
-  # more, the store whose project root is a path prefix of the payload's cwd
-  # decides; if that narrows to anything other than exactly one, pass through
-  # rather than guess (matrix 36).
-  #
-  # "cwd is a path prefix" is checked against the project's REAL checkout
-  # path (projects.yml's own `path:`, e.g. ~/apps/personal/plastic) — never
-  # against StoreDiscovery's `root` (~/.plastic/projects/<slug>, which only
-  # holds INDEX.md and store/). Those are two different directories; a real
-  # session's cwd lives under the former, never the latter. The global store
-  # has no such checkout path, so it never wins by cwd — only by being the
-  # sole candidate.
-  def resolve_intent_dir(id, cwd)
-    pattern = "#{glob_escape(id)}--*"
-    candidates = StoreDiscovery.discover(@plastic_home)[:stores].filter_map do |s|
-      dir = Dir.glob(File.join(s[:store], pattern)).find { |d| File.directory?(d) }
-      dir && { slug: s[:slug], root: s[:root], intent_dir: dir }
-    end
-    return nil if candidates.empty?
-    return candidates.first if candidates.length == 1
-
-    registered = StoreProvisioning.load_projects(@plastic_home)
-    cwd_matches = candidates.select do |c|
-      real_path = registered.dig(c[:slug], "path")
-      real_path && (cwd == real_path || cwd.start_with?("#{real_path}#{File::SEPARATOR}"))
-    end
-    return cwd_matches.first if cwd_matches.length == 1
-
-    nil
-  end
-
-  # A recognized id should just be [A-Za-z0-9]+, but the id comes out of the
-  # assistant's own streamed text, not a trusted schema — escape glob
-  # metacharacters rather than assume it is well-formed.
-  def glob_escape(str)
-    str.gsub(/([*?\[\]{}])/) { "\\#{Regexp.last_match(1)}" }
-  end
 
   def prune_old_buffers
     root = File.join(@tmp_root, BUFFER_DIR_NAME)