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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalom/plastic",
-  "version": "2.0.0-alpha.7",
+  "version": "2.0.0-alpha.8",
   "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/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",

package/scripts/lib/intent_screen.rb

@@ -28,6 +28,19 @@ module IntentScreen
   STEP_PREFIX_RE = /\A(?:Step|S)\s*\d+\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 +139,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/report_screen.rb

@@ -0,0 +1,586 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# ReportScreen (intent 317) - the record readers plus the three renderers
+# (state, delivered, delay) behind scripts/report-screen. Every rendered cell
+# traces to a file on disk (D14): a missing source renders the exact string
+# "not recorded", never a guess or a blank. Pure: explicit paths in, a string
+# out. Dependency injection for anything reaching outside the fixture: the
+# clock is passed as `now:`, git tag reading as `tag_reader:`, and the ANSI
+# renderer path as `renderer_path:` (D2).
+require "time"
+require "json"
+require_relative "intent_screen"
+require_relative "lock"
+
+module ReportScreen
+  NOT_RECORDED = "not recorded"
+
+  # --- shared helpers ----------------------------------------------------------
+
+  def self.intent_basename(intent_dir)
+    File.basename(intent_dir)
+  end
+
+  def self.intent_id(intent_dir)
+    intent_basename(intent_dir).split("--", 2).first
+  end
+
+  def self.intent_file_path(intent_dir)
+    File.join(intent_dir, "#{intent_basename(intent_dir)}.md")
+  end
+
+  def self.intent_text(intent_dir)
+    path = intent_file_path(intent_dir)
+    File.exist?(path) ? File.read(path) : nil
+  end
+
+  def self.spec_text(intent_dir)
+    path = File.join(intent_dir, "spec.md")
+    File.exist?(path) ? File.read(path) : nil
+  end
+
+  def self.outcome_text(intent_dir)
+    path = File.join(intent_dir, "outcome.md")
+    File.exist?(path) ? File.read(path) : nil
+  end
+
+  # The body of a top-level "## Heading" section, stopping at the next "## "
+  # heading (same idiom as IntentScreen.insight_fields). Returns "" when the
+  # heading is absent.
+  def self.section_of(text, heading)
+    return "" unless text
+    text.split(/^#{Regexp.escape(heading)}\s*$/, 2)[1].to_s.split(/^## /, 2)[0].to_s
+  end
+
+  def self.escape(text)
+    text.to_s.gsub("|", "\\|")
+  end
+
+  def self.frontmatter(intent_dir)
+    text = intent_text(intent_dir)
+    return {} unless text && text.start_with?("---")
+    parts = text.split("---", 3)
+    return {} if parts.length < 3
+    require "yaml"
+    require "date"
+    YAML.safe_load(parts[1], permitted_classes: [Date, Time]) || {}
+  rescue StandardError
+    {}
+  end
+
+  def self.research_intent?(intent_dir)
+    Array(frontmatter(intent_dir)["tags"]).map(&:to_s).include?("research")
+  end
+
+  # Markdown pipe-table data rows (header + separator skipped), each an array
+  # of trimmed cell strings. Tolerates leading prose before the table.
+  def self.table_rows(text)
+    lines = text.to_s.lines.map(&:strip).select { |l| l.start_with?("|") }
+    sep_idx = lines.index { |l| l.match?(/\A\|[\s:|-]+\|?\z/) }
+    return [] unless sep_idx
+    lines[(sep_idx + 1)..].map { |l| l.split("|", -1).map(&:strip)[1..-2].to_a }
+  end
+
+  # Every [heading_line, body] pair in a Markdown file, split on ANY heading
+  # line (any level). Used by proven_by (D19) so a section's own matrix rows
+  # are never confused with a sibling section's.
+  def self.split_by_headings(text)
+    sections = []
+    heading = nil
+    body = +""
+    text.to_s.each_line do |line|
+      if line.start_with?("#")
+        sections << [heading, body] if heading
+        heading = line.strip
+        body = +""
+      else
+        body << line
+      end
+    end
+    sections << [heading, body] if heading
+    sections
+  end
+
+  def self.savepoint_lines(intent_dir)
+    path = File.join(intent_dir, "savepoint.md")
+    return [] unless File.exist?(path)
+    File.readlines(path).map(&:strip).reject(&:empty?).filter_map do |line|
+      m = line.match(IntentScreen::SAVEPOINT_RE)
+      m ? [m[1], m[2], m[3]] : nil
+    end
+  end
+
+  def self.human_time(ts)
+    IntentScreen.human_time(ts)
+  end
+
+  def self.title_for(intent_dir, store_root)
+    text = intent_text(intent_dir)
+    return "not recorded" unless text
+    if store_root
+      _status, title = IntentScreen.index_fields(store_root, intent_id(intent_dir))
+      return title if title
+    end
+    IntentScreen.fallback_name(text)
+  end
+
+  def self.default_store_root(intent_dir)
+    File.expand_path("../..", intent_dir)
+  end
+
+  # --- S3: record readers -------------------------------------------------------
+
+  # Row 21: the ## Intent section body only, never the frontmatter `intent:` line.
+  def self.asked(intent_dir)
+    text = intent_text(intent_dir)
+    return NOT_RECORDED unless text
+    body = section_of(text, "## Intent").strip
+    body.empty? ? NOT_RECORDED : body
+  end
+
+  # Row 22: bullets under spec.md's ## Decisions only.
+  def self.decision_count(intent_dir)
+    text = spec_text(intent_dir)
+    return NOT_RECORDED unless text
+    section_of(text, "## Decisions").lines.count { |l| l.lstrip.start_with?("- ") }
+  end
+
+  # Rows 23/24: outcome.md's ## Delivered, table or bullet form.
+  def self.delivered_rows(intent_dir)
+    text = outcome_text(intent_dir)
+    return [] unless text
+    section = section_of(text, "## Delivered")
+    return [] if section.strip.empty?
+
+    rows = table_rows(section)
+    return rows.map { |cells| { label: cells[0].to_s, text: cells[1].to_s } } if rows.any?
+
+    bullets = section.lines.select { |l| l.lstrip.start_with?("- ") }
+    bullets.each_with_index.map do |line, i|
+      { label: (i + 1).to_s, text: line.lstrip.sub(/\A-\s*/, "").strip }
+    end
+  end
+
+  # Rows 25-27: D19 - the label must appear as a standalone token in an action
+  # file heading (any level); the count is the matched section's table rows only.
+  def self.matching_action_heading(intent_dir, label)
+    Dir.glob(File.join(intent_dir, "actions", "*.md")).sort.each do |path|
+      split_by_headings(File.read(path)).each do |heading, body|
+        tokens = heading.to_s.sub(/\A#+\s*/, "").split(/[^A-Za-z0-9]+/)
+        return [heading, body] if tokens.include?(label)
+      end
+    end
+    [nil, nil]
+  end
+
+  def self.proven_by(intent_dir, label)
+    _heading, body = matching_action_heading(intent_dir, label)
+    return NOT_RECORDED unless body
+    n = table_rows(body).length
+    n.positive? ? "#{n} test#{n == 1 ? '' : 's'}" : NOT_RECORDED
+  end
+
+  # Row 34: outcome.md's ## Needs you, our own N1..NN numbering (never the
+  # table's own N column, which could be malformed).
+  def self.needs_you_rows(intent_dir)
+    text = outcome_text(intent_dir)
+    return [] unless text
+    return [] unless text.include?("## Needs you")
+    section = section_of(text, "## Needs you")
+    rows = table_rows(section)
+    rows.each_with_index.map do |cells, i|
+      { n: "N#{i + 1}", what: cells[1].to_s, why: cells[2].to_s }
+    end
+  end
+
+  # Row 35: first-to-last savepoint timestamp, "1 h 51 min" / "n min".
+  def self.duration(intent_dir)
+    lines = savepoint_lines(intent_dir)
+    return NOT_RECORDED if lines.length < 2
+    secs = (Time.parse(lines.last[0]) - Time.parse(lines.first[0])).to_i
+    format_duration(secs)
+  end
+
+  def self.format_duration(secs)
+    mins = [secs, 0].max / 60
+    return "#{mins} min" if mins < 60
+    "#{mins / 60} h #{mins % 60} min"
+  end
+
+  # Row 36 (D20): mode from the LIVE delivery lock's run_mode; absent -> not recorded.
+  def self.mode(intent_dir)
+    data = Lock.read(intent_dir)
+    value = data && data["run_mode"]
+    value && !value.to_s.empty? ? value.to_s : NOT_RECORDED
+  end
+
+  # --- evidence rows (rows 28-33, 37) --------------------------------------------
+
+  def self.suite_row(section)
+    m = section.match(/([\d,]+)\s*runs,\s*([\d,]+)\s*assertions,\s*([\d,]+)\s*failures/)
+    return nil unless m
+    { kind: "suite", what: "#{m[1]} runs · #{m[2]} assertions · #{m[3]} failures", source: "outcome.md ## Verification" }
+  end
+
+  def self.red_row(section)
+    line = section.lines.find { |l| l =~ /\bred\b/i && l =~ /`([0-9a-f]{7,40})`/ }
+    return nil unless line
+    sha = line.match(/`([0-9a-f]{7,40})`/)[1]
+    { kind: "red", what: "#{sha} proven test-only and red", source: "outcome.md ## Verification" }
+  end
+
+  def self.ship_row(text, intent_dir, tag_reader)
+    line = text.to_s.lines.find { |l| l =~ /\bmerge(d)?\b/i && l =~ /\b[0-9a-f]{7,40}\b/ }
+    sha = line && line.match(/\b([0-9a-f]{7,40})\b/)[1]
+    version = tag_reader.call(intent_dir)
+    return nil if sha.nil? && (version.nil? || version.to_s.empty?)
+    ver_text = version && !version.to_s.empty? ? "v#{version.to_s.sub(/\Av/, '')}" : NOT_RECORDED
+    sha_text = sha || NOT_RECORDED
+    { kind: "ship", what: "#{sha_text} → alpha · #{ver_text}", source: "outcome.md; git tags" }
+  end
+
+  def self.doctor_row(text)
+    m = text.to_s.match(/(\d+)\s*pass,?\s*(\d+)\s*warn,?\s*(\d+)\s*fail/i)
+    return nil unless m
+    { kind: "doctor", what: "#{m[1]} pass · #{m[2]} warn · #{m[3]} fail", source: "outcome.md" }
+  end
+
+  def self.deviates_row(section)
+    line = section.lines.find { |l| l.lstrip.sub(/\A-\s*/, "").start_with?("Deviation:") }
+    return nil unless line
+    text = line.lstrip.sub(/\A-\s*/, "").strip
+    { kind: "deviates", what: text, source: "outcome.md ## Verification — Deviation:" }
+  end
+
+  def self.deposits_row(text)
+    line = text.to_s.lines.find { |l| l =~ %r{`resources/[^`]+`} }
+    return nil unless line
+    path = line.match(%r{`(resources/[^`]+)`})[1]
+    { kind: "deposits", what: path, source: "outcome.md" }
+  end
+
+  def self.verdict_row(text)
+    m = text.to_s.match(/verdict[:\s]+([A-Za-z][A-Za-z ]*)/i)
+    return nil unless m
+    { kind: "verdict", what: m[1].strip, source: "outcome.md" }
+  end
+
+  def self.evidence_rows(intent_dir, tag_reader: ->(_dir) { nil })
+    text = outcome_text(intent_dir)
+    return [] unless text
+    verification = section_of(text, "## Verification")
+
+    rows = []
+    rows << suite_row(verification)
+    rows << red_row(verification)
+    rows << (research_intent?(intent_dir) ? nil : ship_row(text, intent_dir, tag_reader))
+    if research_intent?(intent_dir)
+      rows << deposits_row(text)
+      rows << verdict_row(text)
+    end
+    rows << doctor_row(text)
+    rows << deviates_row(verification)
+    rows.compact
+  end
+
+  # --- S4/S5: the state verb and the --all roster --------------------------------
+
+  CHANGED_NOTE = "the reason this screen printed"
+
+  def self.state_fields(intent_dir:, store_root:, changed:)
+    base = intent_basename(intent_dir)
+    id = base.split("--", 2).first
+    text = intent_text(intent_dir)
+    status, title = IntentScreen.index_fields(store_root, id)
+    name = title || IntentScreen.fallback_name(text.to_s)
+
+    f = {}
+    f.merge!(IntentScreen.store_fields(store_root))
+    f["status"] = status
+    f["status.note"] = status == "unlisted" ? "no INDEX.md line names this id" : "listed under ## #{status} in INDEX.md"
+    f.merge!(IntentScreen.savepoint_fields(intent_dir, text.to_s))
+    items = IntentScreen.checklist_items(intent_dir)
+    f.merge!(IntentScreen.progress_fields(items))
+    f.merge!(IntentScreen.next_fields(items, status, checklist_present: IntentScreen.items_present?(intent_dir)))
+    f.merge!(IntentScreen.insight_fields(text.to_s))
+
+    changed_value = changed && !changed.to_s.empty? ? changed.to_s : "on request"
+
+    rows = [
+      ["Store", f["store"], f["store.note"]],
+      ["Status", f["status"], f["status.note"]],
+      ["Stage", f["stage"], f["stage.note"]],
+      ["Savepoint", f["savepoint"], f["savepoint.note"]],
+      ["Progress", "#{f['progress.bar']} #{f['progress.done']} / #{f['progress.total']}", f["progress.note"]],
+      ["Next", f["next"], f["next.note"]],
+      ["Insight", f["insight"], f["insight.note"]],
+      ["Changed", changed_value, CHANGED_NOTE],
+    ]
+    { id: id, name: name, rows: rows, items: items }
+  end
+
+  # Rows 42-46: pad BOTH columns to the widest NOTED label/value, computed on
+  # the raw emitted (already-escaped) cell text; unnoted rows carry no padding.
+  def self.state_rows(rows)
+    escaped = rows.map { |label, value, note| ["**#{label}**", escape(value), escape(note)] }
+    noted = escaped.select { |_, _, note| !note.to_s.empty? }
+    label_w = noted.map { |l, _, _| l.length }.max || 0
+    value_w = noted.map { |_, v, _| v.length }.max || 0
+    escaped.map do |label, value, note|
+      if note.to_s.empty?
+        "| #{label} | #{value} | |"
+      else
+        "| #{label.ljust(label_w)} | #{value.ljust(value_w)} | #{note} |"
+      end
+    end
+  end
+
+  def self.render_state(intent_dir:, store_root:, changed:, template:)
+    data = state_fields(intent_dir: intent_dir, store_root: store_root, changed: changed)
+    out = template.dup
+    out = out.gsub("{{id}}", data[:id])
+    out = out.gsub("{{name}}", data[:name])
+    out = out.gsub("{{fields.rows}}", state_rows(data[:rows]).join("\n"))
+    out = out.gsub("{{steps.rows}}", IntentScreen.steps_rows(data[:items]))
+    out.gsub(/\n{3,}/, "\n\n")
+  end
+
+  # --- roster (D7/D8) -------------------------------------------------------------
+
+  def self.active_dirnames(index_path)
+    return [] unless File.exist?(index_path)
+    dirnames = []
+    section = nil
+    File.foreach(index_path) do |line|
+      if line.start_with?("## ")
+        section = line[3..].strip
+        next
+      end
+      next unless section == "Active"
+      m = line.match(%r{\(store/([^/]+)/})
+      dirnames << m[1] if m
+    end
+    dirnames
+  end
+
+  def self.newest_savepoint_ts(intent_dir)
+    lines = savepoint_lines(intent_dir)
+    lines.last&.first
+  end
+
+  def self.roster(store_root)
+    index_path = File.join(store_root, "INDEX.md")
+    entries = active_dirnames(index_path).filter_map do |dirname|
+      dir = File.join(store_root, "store", dirname)
+      next unless File.directory?(dir)
+      text = intent_text(dir).to_s
+      fields = IntentScreen.savepoint_fields(dir, text)
+      next if fields["stage"] == "Done"
+      { dir: dir, id: dirname.split("--", 2).first, ts: newest_savepoint_ts(dir) }
+    end
+    entries.sort_by { |e| [-(e[:ts] ? Time.parse(e[:ts]).to_i : 0), e[:id]] }
+  end
+
+  def self.lead(intent_dir)
+    data = Lock.read(intent_dir)
+    return "idle" unless data
+    agent = data["owner_agent"].to_s
+    session = data["owner_session"].to_s
+    return "idle" if agent.empty? && session.empty?
+    "#{agent.empty? ? 'unknown' : agent} · #{session[0, 8]}"
+  rescue StandardError
+    "idle"
+  end
+
+  def self.collapsed_open_steps_note(count)
+    count <= 3 ? "#{count} open" : "#{count} open · showing the first three"
+  end
+
+  def self.render_collapsed_block(intent_dir, store_root, changed:)
+    data = state_fields(intent_dir: intent_dir, store_root: store_root, changed: changed)
+    stage = data[:rows].find { |l, _, _| l == "Stage" }[1]
+    nxt = data[:rows].find { |l, _, _| l == "Next" }[1]
+    ch = data[:rows].find { |l, _, _| l == "Changed" }[1]
+
+    open_items = data[:items].each_with_index.reject { |item, _| item[:done] }
+    lines = []
+    lines << "▶ #{data[:id]} · #{data[:name]}"
+    lines << "Stage      #{stage}"
+    lines << "Next       #{nxt}"
+    lines << "Changed    #{ch}"
+    lines << collapsed_open_steps_note(open_items.length)
+    open_items.first(3).each { |item, i| lines << "S#{i + 1}   [ open ]  #{escape(item[:text])}" }
+    lines.join("\n")
+  end
+
+  def self.render_roster(store_root, changed: nil, now: Time.now)
+    entries = roster(store_root)
+    return "No intents in delivery.\n" if entries.empty?
+
+    header = "▶ In delivery · #{entries.length} #{entries.length == 1 ? 'intent' : 'intents'} · " \
+             "#{now.utc.strftime('%Y-%m-%d %H:%M UTC')}"
+    table = ["| Intent | Stage | Progress | Changed | Lead |", "| --- | --- | --- | --- | --- |"]
+    entries.each do |e|
+      text = intent_text(e[:dir]).to_s
+      savepoint = IntentScreen.savepoint_fields(e[:dir], text)
+      items = IntentScreen.checklist_items(e[:dir])
+      progress = IntentScreen.progress_fields(items)
+      ch = state_fields(intent_dir: e[:dir], store_root: store_root, changed: changed)[:rows].find { |l, _, _| l == "Changed" }[1]
+      table << "| #{e[:id]} | #{savepoint['stage']} | #{progress['progress.bar']} #{progress['progress.done']} / #{progress['progress.total']} | #{escape(ch)} | #{lead(e[:dir])} |"
+    end
+    blocks = entries.map { |e| render_collapsed_block(e[:dir], store_root, changed: changed) }
+    head_and_table = ([header, ""] + table).join("\n")
+    # Each collapsed block already has its own internal "\n"; a blank line
+    # separates block from block (design--delivery-reports.html:137-152),
+    # so they read as distinct entries instead of running together.
+    "#{head_and_table}\n\n#{blocks.join("\n\n")}\n"
+  end
+
+  # --- S6: the delivered verb ------------------------------------------------------
+
+  def self.delivered_timestamp(intent_dir)
+    lines = savepoint_lines(intent_dir)
+    done = lines.reverse.find { |_ts, kind, _text| kind == "Done" }
+    done ? human_time(done[0]) : NOT_RECORDED
+  end
+
+  def self.render_delivered(intent_dir:, tag_reader: ->(_dir) { nil })
+    id = intent_id(intent_dir)
+    name = title_for(intent_dir, default_store_root(intent_dir))
+    ts = delivered_timestamp(intent_dir)
+    m = mode(intent_dir)
+    dur = duration(intent_dir)
+    version = tag_reader.call(intent_dir)
+    ver_text = version && !version.to_s.empty? ? "v#{version.to_s.sub(/\Av/, '')}" : NOT_RECORDED
+
+    lines = []
+    lines << "## ✔ #{id} · #{name} · delivered"
+    lines << "#{ts} · #{m} · #{dur} · #{ver_text}"
+    lines << ""
+    lines << "**Asked**"
+    lines << "  #{asked(intent_dir)}"
+    lines << "  #{decision_count(intent_dir)} decisions in spec.md"
+    lines << ""
+    lines << "**Delivered**"
+    lines << "| Row | What | Proven by |"
+    lines << "| --- | --- | --- |"
+    delivered_rows(intent_dir).each do |r|
+      lines << "| #{r[:label]} | #{escape(r[:text])} | #{escape(proven_by(intent_dir, r[:label]))} |"
+    end
+    lines << ""
+    lines << "**Evidence**"
+    lines << "| Kind | What | Source |"
+    lines << "| --- | --- | --- |"
+    evidence_rows(intent_dir, tag_reader: tag_reader).each do |r|
+      lines << "| #{r[:kind]} | #{escape(r[:what])} | #{escape(r[:source])} |"
+    end
+    lines << ""
+    needsyou = needs_you_rows(intent_dir)
+    lines << "**Needs you**"
+    if needsyou.empty?
+      lines << "None"
+    else
+      lines << "| N | What | Why |"
+      lines << "| --- | --- | --- |"
+      needsyou.each { |r| lines << "| #{r[:n]} | #{escape(r[:what])} | #{escape(r[:why])} |" }
+    end
+    "#{lines.join("\n")}\n"
+  end
+
+  # --- S7: the delay verb -----------------------------------------------------------
+
+  def self.delay_timeline(intent_dir)
+    savepoint_lines(intent_dir).map { |ts, kind, text| { ts: ts, kind: kind, text: text } }
+  end
+
+  def self.longest_gap(timeline)
+    return nil if timeline.length < 2
+    best = nil
+    timeline.each_cons(2) do |a, b|
+      secs = (Time.parse(b[:ts]) - Time.parse(a[:ts])).to_i
+      best = { secs: secs, a: a[:kind], b: b[:kind] } if best.nil? || secs > best[:secs]
+    end
+    "longest gap #{best[:secs] / 60} min, #{best[:a]} to #{best[:b]}"
+  end
+
+  def self.where_time_went(timeline)
+    gap = longest_gap(timeline)
+
+    unless timeline.any? { |r| %w[Review Commit].include?(r[:kind]) }
+      parts = ["the review and commit ledger was not kept for this intent"]
+      parts << gap if gap
+      return parts.join(" · ")
+    end
+
+    rounds = timeline.count { |r| r[:kind] == "Review" }
+    commits = timeline.count { |r| r[:kind] == "Commit" }
+    parts = []
+    parts << "reviews #{rounds} round#{rounds == 1 ? '' : 's'}" if rounds.positive?
+    parts << "#{commits} commit#{commits == 1 ? '' : 's'}" if commits.positive?
+    parts << gap if gap
+    parts.join(" · ")
+  end
+
+  def self.hhmm(ts)
+    m = ts.match(/T(\d\d:\d\d)/)
+    m ? m[1] : ts
+  end
+
+  def self.delay_outcome_line(intent_dir)
+    text = outcome_text(intent_dir)
+    return NOT_RECORDED unless text
+    section = section_of(text, "## Summary")
+    # The first PARAGRAPH, not just its first physical line - outcome.md's
+    # prose is hand-wrapped at ~100 columns, so a single logical sentence
+    # spans several source lines.
+    paragraph = section.lstrip.split(/\n\s*\n/, 2).first.to_s.lines.map(&:strip).join(" ").strip
+    return NOT_RECORDED if paragraph.empty?
+    doc = doctor_row(text)
+    doc ? "#{paragraph} · #{doc[:what]}" : paragraph
+  end
+
+  def self.render_delay(intent_dir:)
+    id = intent_id(intent_dir)
+    name = title_for(intent_dir, default_store_root(intent_dir))
+    dur = duration(intent_dir)
+    timeline = delay_timeline(intent_dir)
+
+    lines = []
+    lines << "✔ #{id} · #{name} · delivered in #{dur}"
+    lines << ""
+    timeline.each { |r| lines << "#{hhmm(r[:ts])}  #{r[:kind]}  #{escape(r[:text])}" }
+    lines << ""
+    lines << "**Where the time went**   #{where_time_went(timeline)}"
+    lines << ""
+    lines << "**Outcome**   #{delay_outcome_line(intent_dir)}"
+    "#{lines.join("\n")}\n"
+  end
+
+  # --- S8: --ansi passthrough (D2) -----------------------------------------------
+  #
+  # 316a owns the ANSI renderer; 317 only wires a generic DI seam so this
+  # module never blocks on 316a landing and never breaks when it does (row 77).
+  # A renderer file, when present, is expected to define IntentScreenAnsi.paint
+  # (one plain-text string in, one string out). Wiring the real contract 316a
+  # ships is left to a follow-up step once that file exists (see checklist S14).
+  def self.maybe_paint(text, renderer_path:, enabled:)
+    return text unless enabled
+    return text unless renderer_path && File.exist?(renderer_path)
+
+    begin
+      require renderer_path
+    rescue LoadError, StandardError
+      return text
+    end
+
+    mod = Object.const_get(:IntentScreenAnsi) if Object.const_defined?(:IntentScreenAnsi)
+    return text unless mod && mod.respond_to?(:paint)
+
+    begin
+      mod.paint(text)
+    rescue StandardError
+      text
+    end
+  end
+end

package/scripts/lib/savepoint.rb

@@ -213,6 +213,20 @@ module Savepoint
     append_savepoint_line(intent_dir, "Exec", "started", now)
   end
 
+  # Append a `Review` line: one per plan-review or post-execution-review verdict
+  # (intent 317, D5/D17). Same shape as every other line, through the shared
+  # append_savepoint_line primitive, so dedup and the timestamp format never
+  # drift from the one line-writer every other kind already uses.
+  def self.append_review_savepoint(intent_dir, text, now: Time.now)
+    append_savepoint_line(intent_dir, "Review", text, now)
+  end
+
+  # Append a `Commit` line: one per commit landing during Exec (intent 317,
+  # D5/D17). Same primitive as append_review_savepoint above.
+  def self.append_commit_savepoint(intent_dir, text, now: Time.now)
+    append_savepoint_line(intent_dir, "Commit", text, now)
+  end
+
   TERMINAL_DISPOSITIONS = %w[delivered abandoned].freeze
 
   # Append the terminal bookend `Done  delivered|abandoned`, written by the

package/scripts/report-screen

@@ -0,0 +1,119 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# report-screen - the three delivery-report screens (intent 317): mid-delivery
+# state, post-delivery delivered, and delay. Each fills from the record via
+# scripts/lib/report_screen.rb; no number here is written by eye.
+#
+# Usage:
+#   report-screen state <intent_dir> [--changed "<text>"] [--ansi]
+#   report-screen state --all <store_root> [--changed "<text>"] [--ansi]
+#   report-screen delivered <intent_dir> [--ansi]
+#   report-screen delay <intent_dir> [--ansi]
+#
+# --ansi delegates to 316a's renderer conventions when that file is present
+# (D2) and prints plain otherwise, so this never blocks on 316a and never
+# breaks when it lands; NO_COLOR forces plain regardless of --ansi.
+#
+# Exit codes:
+#   0 - the screen is on stdout
+#   2 - usage error, or the path/store is not what the verb expects (one line
+#       on stderr, stdout empty)
+
+require_relative "lib/report_screen"
+require_relative "lib/intent_screen"
+
+def usage_abort(message)
+  warn "report-screen: #{message}"
+  exit 2
+end
+
+# The one place allowed to shell out (D2/D20): resolves the nearest git tag
+# reachable from the repo this script lives in, so `render_delivered`'s
+# version field and the `ship` evidence row are never invented. The pure
+# module never reads git itself; this is injected as `tag_reader:`.
+def git_tag_reader(repo_root)
+  lambda do |_intent_dir|
+    return nil unless File.exist?(File.join(repo_root, ".git"))
+    tag = `git -C #{repo_root} describe --tags --abbrev=0 2>/dev/null`.strip
+    tag.empty? ? nil : tag
+  end
+end
+
+args = ARGV.dup
+verb = args.shift
+changed = nil
+ansi = false
+template_path = nil
+renderer_path = nil
+positional = []
+
+while (arg = args.shift)
+  case arg
+  when "--changed"
+    usage_abort("--changed needs a value") if args.empty?
+    changed = args.shift
+  when "--ansi"
+    ansi = true
+  when "--all"
+    positional << "--all"
+  when "--template"
+    template_path = args.shift or usage_abort("--template needs a path")
+  when "--renderer-path"
+    renderer_path = args.shift or usage_abort("--renderer-path needs a path")
+  else
+    usage_abort("unknown flag #{arg.inspect}") if arg.start_with?("--") && arg != "--all"
+    positional << arg
+  end
+end
+
+usage_abort("usage: report-screen state|delivered|delay <intent_dir> [--changed \"<text>\"] [--ansi]") unless verb
+
+all_mode = positional.delete("--all") ? true : false
+target = positional.first
+
+renderer_path ||= File.expand_path("../lib/intent_screen_ansi.rb", __dir__)
+ansi_enabled = ansi && ENV["NO_COLOR"].to_s.empty?
+
+def paint(text, ansi_enabled, renderer_path)
+  ReportScreen.maybe_paint(text, renderer_path: renderer_path, enabled: ansi_enabled)
+end
+
+case verb
+when "state"
+  if all_mode
+    usage_abort("usage: report-screen state --all <store_root>") unless target
+    store_root = File.expand_path(target)
+    usage_abort("#{store_root} is not a store (no INDEX.md)") unless File.exist?(File.join(store_root, "INDEX.md"))
+    out = ReportScreen.render_roster(store_root, changed: changed)
+    $stdout.write paint(out, ansi_enabled, renderer_path)
+  else
+    usage_abort("usage: report-screen state <intent_dir> [--changed \"<text>\"]") unless target
+    intent_dir = File.expand_path(target)
+    usage_abort("#{intent_dir} is not an intent directory") unless IntentScreen.intent_dir?(intent_dir)
+    store_root = File.expand_path("../..", intent_dir)
+    template_path ||= File.expand_path("../templates/report-state.md", __dir__)
+    usage_abort("template not found at #{template_path}") unless File.exist?(template_path)
+    out = ReportScreen.render_state(intent_dir: intent_dir, store_root: store_root, changed: changed,
+                                     template: File.read(template_path))
+    $stdout.write paint(out, ansi_enabled, renderer_path)
+  end
+when "delivered"
+  usage_abort("usage: report-screen delivered <intent_dir>") unless target
+  intent_dir = File.expand_path(target)
+  usage_abort("#{intent_dir} is not an intent directory") unless IntentScreen.intent_dir?(intent_dir)
+  repo_root = File.expand_path("..", __dir__)
+  out = ReportScreen.render_delivered(intent_dir: intent_dir, tag_reader: git_tag_reader(repo_root))
+  $stdout.write paint(out, ansi_enabled, renderer_path)
+when "delay"
+  usage_abort("usage: report-screen delay <intent_dir>") unless target
+  intent_dir = File.expand_path(target)
+  usage_abort("#{intent_dir} is not an intent directory") unless IntentScreen.intent_dir?(intent_dir)
+  out = ReportScreen.render_delay(intent_dir: intent_dir)
+  $stdout.write paint(out, ansi_enabled, renderer_path)
+else
+  usage_abort("unknown verb #{verb.inspect} (use state|delivered|delay)")
+end
+
+exit 0

package/scripts/savepoint-note

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# savepoint-note - the writer CLI for the two savepoint kinds intent 317 adds:
+# Review (one line per plan-review or post-execution-review verdict) and
+# Commit (one line per commit landing during Exec). D17: there is no automatic
+# seam for either (session-commit writes the day ledger, not the intent
+# ledger; the executor's own commits are plain git), so this is an explicit
+# thin wrapper on Savepoint.append_review_savepoint / append_commit_savepoint.
+#
+# Usage:
+#   savepoint-note <intent_dir> --kind Review|Commit --text "<text>"
+#
+# --text is normalized (D21): runs of two or more spaces collapse to one, so a
+# free-text kind that happens to contain a double space cannot key the dedup
+# primitive's split(/\s{2,}/) on the prefix alone and silently drop a later
+# line. A newline in --text is refused outright (exit 2, ledger unchanged)
+# rather than silently splitting one entry into two malformed ledger lines.
+#
+# Exit codes:
+#   0 - the line was appended (or was already recorded; both are success)
+#   2 - usage error, bad --kind, missing --text, a newline in --text, or the
+#       path is not an intent directory (one line on stderr, ledger unchanged)
+
+require_relative "lib/savepoint"
+
+def usage_abort(message)
+  warn "savepoint-note: #{message}"
+  exit 2
+end
+
+args = ARGV.dup
+kind = nil
+text = nil
+positional = []
+while (arg = args.shift)
+  case arg
+  when "--kind"
+    kind = args.shift
+  when "--text"
+    text = args.shift
+  else
+    usage_abort("unknown flag #{arg.inspect}") if arg.start_with?("--")
+    positional << arg
+  end
+end
+
+usage_abort("usage: savepoint-note <intent_dir> --kind Review|Commit --text \"<text>\"") unless positional.length == 1
+
+intent_dir = File.expand_path(positional.first)
+usage_abort("#{intent_dir} is not an intent directory") unless File.exist?(Savepoint.intent_file(intent_dir))
+
+KINDS = %w[Review Commit].freeze
+usage_abort("--kind must be one of #{KINDS.join(', ')}, got #{kind.inspect}") unless KINDS.include?(kind)
+usage_abort("--text is required") if text.nil? || text.empty?
+usage_abort("--text must not contain a newline") if text.include?("\n")
+
+normalized = text.gsub(/ {2,}/, " ").strip
+usage_abort("--text is empty after normalization") if normalized.empty?
+
+case kind
+when "Review" then Savepoint.append_review_savepoint(intent_dir, normalized)
+when "Commit" then Savepoint.append_commit_savepoint(intent_dir, normalized)
+end
+
+exit 0

package/scripts/spawn-preamble

@@ -24,6 +24,7 @@
 
 require_relative "lib/savepoint"
 require_relative "lib/worktree"
+require_relative "lib/intent_screen"
 
 # Verbatim honoring instruction. Kept as one constant so the contract doc and the
 # test assert against the exact same string.
@@ -115,11 +116,17 @@ STAGE_LABELS = {
   "exec" => "Exec", "done" => "Done"
 }.freeze
 
+# Intent 317, D6: a dispatched agent's "Current stage:" line must name the last
+# LIFECYCLE line (What/Why/How/Exec/Done), never a trailing Lock/Review/Commit
+# line - the bug spawn-preamble shared with IntentScreen.savepoint_fields
+# before this guard (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/skills/auto/SKILL.md

@@ -200,9 +200,10 @@ Then How.
    into the spec, the matrix, and the tests; record what was dropped and why in the action
    file's review fold. A REVISE verdict is folded and not re-reviewed unless a finding changes
    a decision.
-5. Notify the user (the one mid-flight briefing, per `references/human-report-contract.md`):
-   State, the plan shape and what it builds; Risk, the riskiest row of the matrix; Call,
-   proceeding to build. In auto mode this briefing informs; it does not wait.
+5. Print `ruby ~/.plastic/scripts/report-screen state <intent_dir> --changed "How written, plan review next"`
+   (D15; see `references/human-report-contract.md` for the full trigger list). This replaces
+   the old prose State/Risk/Call briefing at this boundary. In auto mode the screen informs;
+   it does not wait.
 
 Then Exec.
 
@@ -272,6 +273,8 @@ Read `../plastic-conventions/references/completion-and-done.md` for what "intent
    first, or pass `--discard-worktree-changes` deliberately); 3 means the lock survived the
    disarm (`/plastic-doctor check the lock status`); 6 means the structure check refused. Never
    leave an orphaned worktree; run `git worktree prune` on a stale reference.
+6. Print `ruby ~/.plastic/scripts/report-screen delivered <intent_dir>` once (D15): this is the
+   owner report at End, replacing the old prose Done briefing.
 
 ## Error Handling
 
@@ -284,8 +287,8 @@ leaves the project broken.
 
 - Read `references/agent-architecture.md` for the team model, the risk list, the headless note,
   and the solo fallback when dispatching or when a harness has no agent dispatch.
-- Read `references/human-report-contract.md` for the State/Risk/Call briefing before sending the
-  How briefing.
+- Read `references/human-report-contract.md` for the three report screens and the five
+  triggers before printing the How or Completion screen above.
 - Read `references/agent-report-contract.md` for the completion report format when reading a
   dispatched agent's return or synthesizing one.
 - Read `references/end-tail.md` for what `Arm.disarm` does at the End tail and why the reindex

package/skills/auto/references/human-report-contract.md

@@ -1,72 +1,78 @@
-# Human Report Contract (per-stage EM-to-CTO briefing)
-
-This doc defines how the orchestrator briefs the human at each of the five stage boundaries
-(What, Why, How, Exec, Done) in auto mode; for small work only the How boundary fires (see
-`## Depth for small work`). It is the outward, human-facing counterpart to the
-internal report contract in `references/agent-report-contract.md`. Voice: an engineering
-manager briefing a CTO. Lead with impact, name the risk, leave the decision.
-
-## The skeleton
-
-One fixed 3-line shape, reused at every stage:
-
-1. **State**: what happened and what it means, impact first, one line.
-2. **Risk**: the one thing that could bite, or "nothing flagged."
-3. **Call**: the decision left to you, or the go-ahead I am taking.
-
-This is a shape, not a rigid template. Keep the order (State, then Risk, then Call) and keep it
-short. The words can flex to fit the stage.
-
-## Per-stage content
-
-- **What**: State = the work I picked up and why it matters now. Risk = scope uncertainty.
-  Call = confirm this is worth doing, or I proceed.
-- **Why**: State = the approach I chose, one line. Risk = the main trade-off. Call = the one
-  decision I need (approve, or pick an option).
-- **How**: State = the plan shape (task count and what it builds). Risk = the riskiest task or
-  dependency. Call = approve the plan to build.
-- **Exec**: State = what got built and the test result. Risk = residual failures or deviations.
-  Call = go to review, or done.
-- **Done**: State = the delivered impact. Risk = residual risk. Call = the decision left to you
-  (merge, release, accept).
+# Human Report Contract (the three report screens, intent 317)
+
+D15: the prose EM-to-CTO briefing this doc used to define is retired. The orchestrator now
+prints one of three report screens, filled from the record by `scripts/report-screen`, never
+written by eye:
+
+- **`report-screen state <intent_dir> [--changed "<text>"]`** - the mid-delivery report. One
+  intent's field table (Store, Status, Stage, Savepoint, Progress, Next, Insight) plus a
+  `Changed` row naming what caused the print, and its Steps table.
+- **`report-screen state --all <store_root>`** - the roster across every in-delivery intent,
+  most recently changed first, then one collapsed block (Stage, Next, Changed, first three
+  open steps) per intent.
+- **`report-screen delivered <intent_dir>`** - the post-delivery report, printed once at close:
+  Asked, Delivered (with a Proven-by column), Evidence, Needs you.
+- **`report-screen delay <intent_dir>`** - printed only on request ("why did X take so long"):
+  the delivery as a timeline plus the derived `Where the time went` line.
+
+## The five triggers for `state`
+
+Print `state` (one intent, or `--all` for the roster) on any of these; a checklist tick alone,
+an executor's intermediate commit, or an agent going idle is NOT one of them:
+
+| Trigger | Scope |
+|---|---|
+| A savepoint line lands (a stage boundary: Why, How, Exec started, outcome written, Done) | that intent |
+| A review verdict returns (plan review or post-execution review), naming what it changed | that intent |
+| A blocker or needs-input is logged | that intent |
+| A merge or a release lands | that intent |
+| The owner asks ("where are we", "state of X", "continue X") | all in delivery, or the one named |
+
+`delivered` prints exactly once, at Completion. `delay` prints only when the owner asks why a
+delivery took long.
+
+Every verb prints the same plain Markdown on every harness (owner ruling 2026-08-31); where a
+harness can paint it (Claude Code, through 316a's message-display hook), it substitutes a
+painted rendering of that same output, never a different one, and no skill or script branches
+on harness name to decide.
 
 ## Depth for small work
 
-For small work in auto mode the mid-flight briefings collapse to one. Only the How briefing fires, and
-it folds in what the What and Why briefings would have said: the work picked up and the approach
-chosen go into its State line. The Exec briefing folds into the final owner report at End. Larger
-work sends all four. The shape does not change: still State, then Risk, then Call, and the per-stage
-content above still says what each line covers. This is a depth cut, not a new report. A delivery
-still ends with `outcome.md` plus one owner report.
+For small work in auto mode, only the How-boundary `state` screen prints mid-flight (its
+`Changed` row names what the What and Why steps did, since there is no separate briefing per
+stage any more). Larger work prints `state` at every trigger in the table above. This is a
+depth cut, not a different report: the screen's shape never changes, only how often it fires.
+A delivery still ends with `outcome.md` plus one `delivered` screen.
 
 ## One report per audience
 
 A delivery produces exactly two artifacts: `outcome.md` (authored by `plastic-intent-ending`)
-and one EM-to-CTO owner report at the End stage. No stage or skill restates a delivery
-already written to `outcome.md`; point at it instead. Skills do not open with a banner that
-names the skill or restates the intent id and name the owner just typed. Announce only what
-the reader cannot already know: an error, a result, a choice with its reason, or a handoff.
+and one `delivered` screen at the End stage. No stage or skill restates a delivery already
+written to `outcome.md`; point at it instead. Skills do not open with a banner that names the
+skill or restates the intent id and name the owner just typed. Announce only what the reader
+cannot already know: an error, a result, a choice with its reason, or a handoff.
 
 ## Boundary vs intent 74
 
 Intent 74's report contract (`references/agent-report-contract.md`) is the INTERNAL,
 machine-checked handoff from a dispatched specialist back to the orchestrator: a structured
-envelope plus a per-role payload. This contract is the OUTWARD human briefing, orchestrator to
-user, in prose. Different direction, different audience, different form. The orchestrator
-CONSUMES the intent 74 report to WRITE the human briefing defined here. The two never merge.
+envelope plus a per-role payload. This contract is the OUTWARD screen shown to the owner.
+Different direction, different audience, different form. The orchestrator reads the intent 74
+report and reflects it into the record (savepoint, outcome.md) that `report-screen` then
+renders. The two never merge.
 
 ## Brevity: point, don't repeat
 
-Surface rules are owned by the `writing-style` skill. This contract does not restate them, in full
-or in summary. It defines the report's shape only: what to say, in what order, and when to stop.
-Apply the `writing-style` skill for the wording.
+Surface rules are owned by the `writing-style` skill. This contract does not restate them. Its
+job is naming which screen prints when, not the wording inside it - `report-screen` derives
+every cell from the record (D14), so there is no prose left to style here.
 
 ## Emission: guided vs auto
 
-In guided mode, the briefing lands at each stage boundary and the human acts on the Call line
-before the next stage starts.
+In guided mode, `state` prints at each stage boundary and the human decides before the next
+stage starts.
 
-In auto mode, for larger work the orchestrator still emits the briefing at each boundary, as a
-running EM-to-CTO account. For small work only the How briefing fires; see `## Depth for small work` above for what it
-folds in. The Call line becomes the go-ahead the orchestrator takes itself and moves on, except at
-the existing hard stops (destructive action without a safe alternative, project-path confirm).
+In auto mode, `state` prints at every trigger for larger work; for small work only the How
+boundary prints (see `## Depth for small work` above). The orchestrator takes the go-ahead
+itself and moves on, except at the existing hard stops (destructive action without a safe
+alternative, project-path confirm).

package/skills/intent-continuing/SKILL.md

@@ -103,20 +103,25 @@ For a live intent's directory:
    the next thing the stage needs (see the matrix). The newest `## Insights` entry supplies
    the human-readable context; an entry marked `(autonomous)` means an auto team was
    delivering it, so say so and offer to hand back to `plastic-auto`.
-5. **Print the intent screen as the first thing in the reply, then continue at that stage.**
+5. **Print the report screen as the first thing in the reply, then continue at that stage.**
    The screen must open the message with nothing before it. On Claude Code, a fail-open
    `MessageDisplay` hook recognizes a reply that opens this way and substitutes a styled ANSI
    rendering for it there; the transcript and every other harness keep exactly this plain
-   form, and nothing about how the screen is printed here ever changes. Run
-   `ruby ~/.plastic/scripts/intent-screen <intent_dir>` and print its output as it is: the
-   title, the field table, and the Steps table come from the record, never by eye. Under it
+   form. For "where are we" on one named intent, run
+   `ruby ~/.plastic/scripts/report-screen state <intent_dir>` and print its output as it is:
+   the title, the field table, the `Changed` row, and the Steps table come from the record,
+   never by eye. For "where are we" with no intent named, run
+   `ruby ~/.plastic/scripts/report-screen state --all <store_root>` for the roster across every
+   in-delivery intent. Route "why did X take so long" to
+   `ruby ~/.plastic/scripts/report-screen delay <intent_dir>` instead - every verb prints the
+   same plain screen on any harness, painted only where the harness supports it, with no
+   branching on harness name. Under the `state` screen
    write **What this means** as two to four bullets in plain words (what the intent is for,
-   what has landed, what is left, any defect named by step), then close with
-   **needs input:** naming the first open step. The screen's shape is
-   `~/.plastic/templates/intent-screen.md`; the script fills it, the session never edits the numbers.
-   Then continue the work in the session's current mode. In auto mode the running team
-   already holds the delivery lock; if a lock is held by a session that is gone, the
-   `plastic-doctor` skill's lock section repairs or reclaims it.
+   what has landed, what is left, any defect named by step), then close with **needs input:**
+   naming the first open step. Then continue the work in the
+   session's current mode. In auto mode the running team already holds the delivery lock; if a
+   lock is held by a session that is gone, the `plastic-doctor` skill's lock section repairs or
+   reclaims it.
 
 ## Roadmap route: resume the mid-flight roadmap
 

package/skills/intent-ending/SKILL.md

@@ -63,8 +63,11 @@ on disk is what the record becomes, so before the call:
 
 Author outcome.md yourself when it deserves prose: copy `templates/outcome.md`,
 set the frontmatter to `disposition: delivered` or `disposition: abandoned`, and
-fill `## Summary`, `## Delivered`, `## Verification`, `## Follow-ups`. On
-abandon, `## Summary` states the abandonment reason and the trail (see Pivot
+fill `## Summary`, `## Delivered`, `## Verification`, `## Follow-ups`. Each
+`## Delivered` row is one thing delivered in plain wording a reader recognizes,
+not a method name or an implementation summary (that detail belongs in
+`## Summary`) - it becomes a row of `report-screen delivered`'s post-delivery
+screen. On abandon, `## Summary` states the abandonment reason and the trail (see Pivot
 below). A placeholder outcome.md is backfilled from the record instead, with the
 close's disposition and the `--outcome-summary` line as its summary. Also author
 the rich INDEX entry note now (a short line in the store's existing

package/skills/intent-executing/SKILL.md

@@ -61,6 +61,8 @@ Run Step 0 (Sync Worktree First) before this step.
 
 Dispatch ONE executor subagent and give it the whole delivery: every task's full text from `plan.md` (pasted in, never a file reference), every action file with its failure-mode matrix, the checklist items it must tick, the project context from CLAUDE.md, the active intent context from `{ID}--{slug}.md`, and the worktree path. In auto mode this is the `plastic-executor` agent; elsewhere use the `implementer-prompt.md` template. The executor writes the matrix's tests and commits them red, implements the consolidated action in order, ticks each item as it lands (see `## Tick-as-you-land`), and drives the test suite green.
 
+After each commit lands (the red commit and every commit after it), append a `Commit` line to the savepoint ledger: `ruby ~/.plastic/scripts/savepoint-note <intent_dir> --kind Commit --text "<sha> <what it proves>"` (intent 317, D17). This is what feeds `report-screen delay`; a commit with no line is a gap the delay report cannot explain.
+
 Read its response by code:
 - DONE or DONE_WITH_CONCERNS → proceed to Step 3.
 - NEEDS_CONTEXT → provide the missing context, re-dispatch the executor.
@@ -69,6 +71,10 @@ Read its response by code:
 ### Step 3: Review by Risk
 Apply the auto skill's risk rule to the executor's return and the diff: a matrix row no test could prove, a diff touching a hook, the lock, the worktree code, the installer, or a release file, a DONE_WITH_CONCERNS or a deviation from the matrix, or an owner-facing surface no test pins. When a rule fires, dispatch the post-execution reviewer with `code-quality-reviewer-prompt.md` (a separate agent with fresh context, never the maker); if it returns changes, re-dispatch the executor to fix them, then run the suite once more. When no rule fires, the green suite is the review.
 
+Whenever a review verdict returns - the plan review before code, or the post-execution review above - the lead appends a `Review` line: `ruby ~/.plastic/scripts/savepoint-note <intent_dir> --kind Review --text "<verdict, what changed>"` (intent 317, D17). This is the other half of what `report-screen delay` reads.
+
+**The D19 heading convention.** An action file's `## Delivered` row (in `outcome.md`) is proven by whichever `actions/ACTION_N.md` heading carries that row's label as a standalone token - `### Row A -` proves row A, `### S1 -` proves row S1. Write action-file section headings so the label they prove is unambiguous (never a substring another label could also match, like `A` inside `AB`); `report-screen delivered`'s Proven-by column renders `not recorded` when no heading matches.
+
 ### Step 4: Update Intent and Complete
 Capture observations in `## Insights`. When ALL checklist items are checked:
 

package/templates/outcome.md

@@ -7,10 +7,15 @@ disposition: delivered|abandoned
 (what was delivered)
 
 ## Delivered
+<!-- One row per thing delivered, in plain wording a reader recognizes, not
+an implementation summary; the technical detail belongs in ## Summary. -->
 - ...
 
 ## Verification
 - <acceptance criterion> — verified by ... → result
 
+## Needs you
+None
+
 ## Follow-ups
 None

package/templates/report-state.md

@@ -0,0 +1,11 @@
+## ▶ {{id}} · {{name}}
+
+| | | |
+| --- | --- | --- |
+{{fields.rows}}
+
+**Steps**
+
+| Step | Status | What |
+| --- | --- | --- |
+{{steps.rows}}