@zalom/plastic 2.0.0-alpha.8 → 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.8",
+  "version": "2.0.0-alpha.9",
   "description": "Intent-driven idea development system for AI coding agents",
   "type": "module",
   "bin": {

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

@@ -452,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,8 +24,11 @@ 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

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)

package/scripts/lib/report_screen.rb

@@ -139,6 +139,31 @@ module ReportScreen
     body.empty? ? NOT_RECORDED : body
   end
 
+  PLACEHOLDER_SENTINEL = "<!-- plastic:placeholder -->"
+
+  # 317a S3 (A6): the note under Asked. Bulleted decisions in a real spec keep
+  # the historic "N decisions in spec.md"; a prose ## Decisions falls back to
+  # the highest D<n> it names; a placeholder spec falls through to the intent
+  # record's "### Decisions" (which section_of's "^## " anchor cannot reach);
+  # nothing anywhere says "decisions not recorded" - never a false 0, and the
+  # scaffold's "- ..." never counts as 1.
+  def self.decision_note(intent_dir)
+    spec = spec_text(intent_dir)
+    if spec && !spec.lstrip.start_with?(PLACEHOLDER_SENTINEL)
+      n = decisions_in(section_of(spec, "## Decisions"))
+      return "#{n} decisions in spec.md" if n.positive?
+    end
+    n = decisions_in(intent_text(intent_dir).to_s.split(/^### Decisions\s*$/, 2)[1].to_s.split(/^#+ /, 2)[0])
+    return "#{n} decisions in the intent record" if n.positive?
+    "decisions not recorded"
+  end
+
+  def self.decisions_in(body)
+    bullets = body.to_s.lines.count { |l| s = l.lstrip; s.start_with?("- ") && s.strip != "- ..." }
+    return bullets if bullets.positive?
+    body.to_s.scan(/\bD(\d{1,3})\b/).flatten.map(&:to_i).max.to_i
+  end
+
   # Row 22: bullets under spec.md's ## Decisions only.
   def self.decision_count(intent_dir)
     text = spec_text(intent_dir)
@@ -156,10 +181,28 @@ module ReportScreen
     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 }
+    bullet_rows(section).each_with_index.map do |text, i|
+      { label: (i + 1).to_s, text: text }
+    end
+  end
+
+  # 317a S1 (matrix S1a/S1b): a bullet row is its "- " line PLUS its wrapped
+  # continuation lines - outcome prose is hand-wrapped at ~100 columns, and
+  # taking one physical line truncated every real record mid-sentence. A blank
+  # line or a heading ends the row; prose after a blank is never swept in.
+  def self.bullet_rows(section)
+    rows = []
+    section.to_s.each_line do |line|
+      stripped = line.strip
+      if line.lstrip.start_with?("- ")
+        rows << line.lstrip.sub(/\A-\s*/, "").strip
+      elsif stripped.empty? || line.start_with?("#")
+        rows << nil unless rows.empty? || rows.last.nil?
+      elsif !rows.empty? && !rows.last.nil?
+        rows[rows.length - 1] = "#{rows.last} #{stripped}"
+      end
     end
+    rows.compact
   end
 
   # Rows 25-27: D19 - the label must appear as a standalone token in an action
@@ -189,9 +232,21 @@ module ReportScreen
     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 }
+    if rows.any?
+      return rows.each_with_index.map do |cells, i|
+        { n: "N#{i + 1}", what: cells[1].to_s, why: cells[2].to_s }
+      end
     end
+
+    # 317a S2 (matrix S2a): prose that exists must never render as None - the
+    # 317 record hid three owner picks behind exactly that. One joined row,
+    # why "not recorded"; a literal None (or an empty section) stays [].
+    content = section.gsub(/<!--.*?-->/m, "").strip
+    return [] if content.empty? || content == "None"
+
+    what = content.lines.map(&:strip).reject(&:empty?)
+                  .join(" ").sub(/\A-\s*/, "").squeeze(" ")
+    [{ n: "N1", what: what, why: NOT_RECORDED }]
   end
 
   # Row 35: first-to-last savepoint timestamp, "1 h 51 min" / "n min".
@@ -212,9 +267,27 @@ module ReportScreen
   def self.mode(intent_dir)
     data = Lock.read(intent_dir)
     value = data && data["run_mode"]
+    return value.to_s if value && !value.to_s.empty?
+
+    # 317a S7 (D5): after the close the lock is gone; end-intent stamps the
+    # run_mode into outcome.md frontmatter, so mode stops being unknowable
+    # retrospectively. Live lock first - it is the source of truth mid-flight.
+    value = outcome_frontmatter(intent_dir)["mode"]
     value && !value.to_s.empty? ? value.to_s : NOT_RECORDED
   end
 
+  def self.outcome_frontmatter(intent_dir)
+    text = outcome_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
+
   # --- evidence rows (rows 28-33, 37) --------------------------------------------
 
   def self.suite_row(section)
@@ -460,7 +533,7 @@ module ReportScreen
     lines << ""
     lines << "**Asked**"
     lines << "  #{asked(intent_dir)}"
-    lines << "  #{decision_count(intent_dir)} decisions in spec.md"
+    lines << "  #{decision_note(intent_dir)}"
     lines << ""
     lines << "**Delivered**"
     lines << "| Row | What | Proven by |"
@@ -470,10 +543,18 @@ module ReportScreen
     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])} |"
+    ev = evidence_rows(intent_dir, tag_reader: tag_reader)
+    if ev.empty?
+      # 317a S4 (matrix S4a): a header-only table (319's live rendering) says
+      # nothing; the honest floor is the same phrase every other absent source
+      # prints.
+      lines << NOT_RECORDED
+    else
+      lines << "| Kind | What | Source |"
+      lines << "| --- | --- | --- |"
+      ev.each do |r|
+        lines << "| #{r[:kind]} | #{escape(r[:what])} | #{escape(r[:source])} |"
+      end
     end
     lines << ""
     needsyou = needs_you_rows(intent_dir)
@@ -564,23 +645,4 @@ module ReportScreen
   # 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/screen_paint.rb

@@ -0,0 +1,218 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require_relative "intent_screen_ansi"
+
+# ScreenPaint (intent 317a, D1) - the paint seam 317's Needs-you named. Parses
+# the plain Markdown screens our own renderers emit (intent, state, roster,
+# delivered, delay) and re-lays them out in the shipped intent-screen ANSI
+# vocabulary. A parser and RE-LAYOUTER, not a colorizer (A5): the plain
+# screens are pipe tables whose scaffolding rows only disappear under a
+# Markdown renderer, so the painter drops them and rebuilds the layout;
+# content-survival is the contract - every value and note survives, nothing
+# is invented, and text it does not recognize returns nil so every caller
+# fails open to plain.
+#
+# Harness-agnostic core: no harness assumption lives here. No ENV, no TTY. Color, width, and
+# markdown_safe are caller arguments, exactly like IntentScreenAnsi before it
+# (316a1); the 318 ceiling holds - the palette is IntentScreenAnsi's, no new
+# colors, no box borders.
+module ScreenPaint
+  A = IntentScreenAnsi
+
+  # A screen's first line: "## ▶ id · name", "## ✔ id · name · delivered",
+  # "▶ In delivery · ...", "✔ id · name · delivered in ...".
+  OPENER_RE = /\A(?:## )?[▶✔] .+ · /.freeze
+
+  FIELD_LINE_RE = /\A(Stage|Next|Changed|Lead|Progress)(\s{2,})(.*)\z/.freeze
+  STEP_LINE_RE = /\A(S\d+)\s+\[ (open|done) \]\s+(.*)\z/.freeze
+  TIMELINE_RE = /\A(\d\d:\d\d)\s{2}(\S+)\s{2}(.*)\z/.freeze
+  COUNT_LINE_RE = /\A\d+ open( · .*)?\z/.freeze
+  BOLD_LEAD_RE = /\A\*\*([^*]+)\*\*(.*)\z/.freeze
+
+  module_function
+
+  # The classifier both paint and region_end share. `idx`/`opener_idx` give
+  # the positional rule its footing: the line right after a title is the meta
+  # line (delivered/delay print one), recognizable by its " · " separators.
+  def classify(line, idx: nil, opener_idx: nil)
+    text = line.chomp
+    stripped = text.strip
+    return :blank if stripped.empty?
+    return :opener if OPENER_RE.match?(stripped) && text == stripped
+    return :table if text.lstrip.start_with?("|")
+    return :bold if BOLD_LEAD_RE.match?(stripped) && text == stripped
+    return :meta if idx && opener_idx && idx == opener_idx + 1 && stripped.include?(" · ")
+    return :indented if text.start_with?("  ")
+    return :field if FIELD_LINE_RE.match?(text)
+    return :step if STEP_LINE_RE.match?(text)
+    return :timeline if TIMELINE_RE.match?(text)
+    return :count if COUNT_LINE_RE.match?(stripped)
+    return :closer if ["None", "not recorded", "No intents in delivery."].include?(stripped)
+    :unknown
+  end
+
+  # Where the screen region ends inside a larger message (B10): walk from the
+  # opener while every line classifies; the first unknown line - ordinary
+  # prose, a prose bullet - is the boundary. Never consumes past the screen.
+  def region_end(lines, start_idx)
+    i = start_idx + 1
+    while i < lines.length
+      kind = classify(lines[i], idx: i, opener_idx: start_idx)
+      break if kind == :unknown
+      # A bare "**Section**" head belongs to the screen only when what follows
+      # is still grammar; "**What this means**" over prose bullets is the
+      # model's own commentary and stays outside, unsplit (B10).
+      if kind == :bold && bare_bold?(lines[i]) && !grammar_follows?(lines, i, start_idx)
+        break
+      end
+      i += 1
+    end
+    # Trailing blanks belong to the message, not the screen.
+    i -= 1 while i > start_idx + 1 && lines[i - 1].strip.empty?
+    i
+  end
+
+  def bare_bold?(line)
+    m = BOLD_LEAD_RE.match(line.strip)
+    m && m[2].to_s.strip.empty?
+  end
+
+  def grammar_follows?(lines, idx, opener_idx)
+    j = idx + 1
+    j += 1 while j < lines.length && lines[j].strip.empty?
+    return false if j >= lines.length
+    kind = classify(lines[j], idx: j, opener_idx: opener_idx)
+    kind != :unknown && kind != :opener
+  end
+
+  # The painter. Returns the ANSI (or plain re-laid, when color: false) text,
+  # or nil when the input does not open with a screen title or carries a line
+  # outside the grammar - the caller's cue to print the original untouched.
+  def paint(text, color: true, width: A::DEFAULT_WIDTH, markdown_safe: false)
+    lines = text.to_s.lines
+    first_idx = lines.index { |l| !l.strip.empty? }
+    return nil if first_idx.nil?
+    return nil unless classify(lines[first_idx]) == :opener
+
+    out = +""
+    table = []
+    ok = true
+
+    flush = lambda do
+      next if table.empty?
+      out << paint_table(table, color: color, width: width, markdown_safe: markdown_safe)
+      table.clear
+    end
+
+    lines.each_with_index do |line, idx|
+      kind = classify(line, idx: idx, opener_idx: first_idx)
+      if kind == :table
+        table << line.strip
+        next
+      end
+      flush.call
+      case kind
+      when :opener
+        t = clean(line.strip.sub(/\A## /, ""), markdown_safe)
+        out << A.fit(t, width) { |s| A.styled(s, color, A::BOLD, A::NEARWHITE) } << "\n"
+      when :meta
+        out << A.fit(clean(line.strip, markdown_safe), width) { |s| A.styled(s, color, A::MIDGREY) } << "\n"
+      when :bold
+        m = BOLD_LEAD_RE.match(line.strip)
+        head = A.styled(clean(m[1], markdown_safe), color, A::BOLD, A::NEARWHITE)
+        out << head << clean(m[2], markdown_safe) << "\n"
+      when :indented
+        out << A.fit_plain(clean(line.chomp, markdown_safe), width) << "\n"
+      when :field
+        m = FIELD_LINE_RE.match(line.chomp)
+        out << A.styled(m[1].ljust(8), color, A::BOLD) << "  " << clean(m[3], markdown_safe) << "\n"
+      when :step
+        m = STEP_LINE_RE.match(line.chomp)
+        badge = A.status_cell(m[2] == "done", color)
+        out << "#{m[1].ljust(4)} [#{badge}]  #{A.fit_plain(clean(m[3], markdown_safe), width - 12)}\n"
+      when :timeline
+        m = TIMELINE_RE.match(line.chomp)
+        out << A.styled(m[1], color, A::MIDGREY) << "  " << A.styled(m[2].ljust(6), color, A::BOLD) \
+            << "  " << clean(m[3], markdown_safe) << "\n"
+      when :count
+        out << A.fit(line.strip, width) { |s| A.styled(s, color, A::MIDGREY) } << "\n"
+      when :closer
+        out << A.styled(line.strip, color, A::MIDGREY) << "\n"
+      when :blank
+        out << "\n"
+      else
+        ok = false
+        break
+      end
+    end
+    flush.call
+    return nil unless ok
+
+    paint_bars(out.gsub(/\n{3,}/, "\n\n"), color)
+  end
+
+  # --- tables -----------------------------------------------------------------
+
+  SEPARATOR_RE = /\A\|[\s:|-]+\|?\z/.freeze
+
+  def cells_of(row)
+    row.split("|", -1).map(&:strip)[1..-2].to_a
+  end
+
+  def field_table?(rows)
+    rows.first&.gsub(/[\s|]/, "") == "" || cells_of(rows.first).first.to_s.start_with?("**")
+  end
+
+  # A field table ("| | | |" scaffold, "| **Key** | value | note |" rows)
+  # re-lays as the intent screen's vertical field block: bold key, value,
+  # mid-grey note on its own line. A data table re-lays as padded columns
+  # with a bold header, done/open cells colored, no pipes anywhere.
+  def paint_table(rows, color:, width:, markdown_safe:)
+    rows = rows.reject { |r| SEPARATOR_RE.match?(r) || r.gsub(/[\s|]/, "").empty? }
+    return "" if rows.empty?
+
+    if cells_of(rows.first).first.to_s.start_with?("**")
+      out = +""
+      key_w = rows.map { |r| cells_of(r).first.to_s.gsub("*", "").length }.max
+      rows.each do |row|
+        key, value, note = cells_of(row)
+        key = key.to_s.gsub("*", "")
+        out << "  #{A.styled(key.ljust(key_w), color, A::BOLD)}  #{clean(value.to_s, markdown_safe)}\n"
+        next if note.to_s.empty?
+        out << (" " * (key_w + 4)) << A.fit(clean(note, markdown_safe), width - key_w - 4) { |s| A.styled(s, color, A::MIDGREY) } << "\n"
+      end
+      return out
+    end
+
+    grid = rows.map { |r| cells_of(r).map { |c| clean(c, markdown_safe) } }
+    widths = grid.first.each_index.map { |i| grid.map { |r| r[i].to_s.length }.max }
+    out = +""
+    grid.each_with_index do |cols, ri|
+      cells = cols.each_with_index.map do |cell, ci|
+        padded = cell.to_s.ljust(widths[ci])
+        if ri.zero?
+          A.styled(padded, color, A::BOLD)
+        elsif cell == "done"
+          A.styled(padded, color, A::TEAL)
+        elsif cell == "open"
+          A.styled(padded, color, A::AMBER)
+        else
+          padded
+        end
+      end
+      out << "  " << cells.join("  ").rstrip << "\n"
+    end
+    out
+  end
+
+  def paint_bars(text, color)
+    return text unless color
+    text.gsub(/█+/) { |run| "#{A::TEAL}#{run}#{A::RESET}" }
+        .gsub(/░+/) { |run| "#{A::MIDGREY}#{run}#{A::RESET}" }
+  end
+
+  def clean(text, markdown_safe)
+    markdown_safe ? A.clean(text) : text
+  end
+end

package/scripts/report-screen

@@ -12,9 +12,11 @@
 #   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.
+# --ansi delegates to ScreenPaint (intent 317a, D1), the parser/re-layouter
+# in the shared TUI core. Selection is by capability, never by harness:
+# NO_COLOR forces plain, a non-TTY stdout stays plain unless
+# PLASTIC_FORCE_COLOR=1 (the test seam), and an unparseable screen falls
+# open to the plain text untouched.
 #
 # Exit codes:
 #   0 - the screen is on stdout
@@ -23,6 +25,7 @@
 
 require_relative "lib/report_screen"
 require_relative "lib/intent_screen"
+require_relative "lib/screen_paint"
 
 def usage_abort(message)
   warn "report-screen: #{message}"
@@ -46,7 +49,6 @@ verb = args.shift
 changed = nil
 ansi = false
 template_path = nil
-renderer_path = nil
 positional = []
 
 while (arg = args.shift)
@@ -60,8 +62,6 @@ while (arg = args.shift)
     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
@@ -73,11 +73,12 @@ usage_abort("usage: report-screen state|delivered|delay <intent_dir> [--changed
 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?
+ansi_enabled = ansi && ENV["NO_COLOR"].to_s.empty? &&
+               ($stdout.tty? || ENV["PLASTIC_FORCE_COLOR"] == "1")
 
-def paint(text, ansi_enabled, renderer_path)
-  ReportScreen.maybe_paint(text, renderer_path: renderer_path, enabled: ansi_enabled)
+def paint(text, ansi_enabled, _renderer_path = nil)
+  return text unless ansi_enabled
+  ScreenPaint.paint(text, color: true) || text
 end
 
 case verb
@@ -87,7 +88,7 @@ when "state"
     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)
+    $stdout.write paint(out, ansi_enabled)
   else
     usage_abort("usage: report-screen state <intent_dir> [--changed \"<text>\"]") unless target
     intent_dir = File.expand_path(target)
@@ -97,7 +98,7 @@ when "state"
     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)
+    $stdout.write paint(out, ansi_enabled)
   end
 when "delivered"
   usage_abort("usage: report-screen delivered <intent_dir>") unless target
@@ -105,13 +106,13 @@ when "delivered"
   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)
+  $stdout.write paint(out, ansi_enabled)
 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)
+  $stdout.write paint(out, ansi_enabled)
 else
   usage_abort("unknown verb #{verb.inspect} (use state|delivered|delay)")
 end

package/skills/auto/SKILL.md

@@ -253,7 +253,8 @@ every choice is non-destructive and the team has full autonomy.
 Read `../plastic-conventions/references/completion-and-done.md` for what "intent done" means.
 
 1. Verify every checklist item is checked and the suite is green once on the branch.
-2. Write `outcome.md` from `~/.plastic/templates/outcome.md` with `disposition: delivered`.
+2. Write `outcome.md` from `~/.plastic/templates/outcome.md` with `disposition: delivered`,
+   `## Delivered` as the labeled table whose row labels match the action-file headings (317a).
 3. Release, if configured: match the working directory against `~/.plastic/projects.yml`, read
    `project.yml`'s `release` block, and act on `on_complete` (`commit`, `commit_and_push`,
    `manual`), `verify` (green proceeds; red follows `on_red`: `fix_and_retry` up to twice,

package/skills/conventions/references/locks-and-worktrees.md

@@ -103,3 +103,15 @@ what gets written down.
 | Exec | code on the intent branch, checklist checked off | heartbeat; code edits confined to the provisioned worktree; delegates write under the owner's lock | checklist boxes; savepoint milestones; the day-ledger line promotes when a project file lands |
 | End (done) | mandatory `outcome.md` (`disposition: delivered\|abandoned`), INDEX moves to Completed or Abandoned | ordered End tail: verify, merge and remove worktrees, disarm clears `delivery.lock`, then the pointer is purge-eligible, and the QMD reindex runs LAST (after purge); `end-intent` backfills a placeholder `outcome.md` from the record and its structure check reports (never refuses) | savepoint `Done delivered` (or `abandoned`); takeover audits, if any, remain in savepoint.md |
 | Maintenance (Future, Terminal, or Active-with-a-stale-or-no-lock) | `revisions.md` move-and-record entries | detects (never acquires) `delivery.lock`; defers and reports while the target's lock is FRESH (`Lock.fresh?`); a stale or absent lock is not-active, maintenance proceeds | append-only, rule-tagged `revisions.md` entry written in the same operation as the change, or the change is refused; lands via a fresh branch off store main merged back as one closed op, never `git add -A` |
+
+## The write guard is not residue
+
+`<type>.write.lock` (usually `delivery.write.lock`) is a deliberate sibling
+inode used only for `flock`: no owner, no timestamp, no content, and it is
+NEVER unlinked - deleting it while a writer holds the flock hands the next
+writer a fresh inode at the same path, so two writers hold "the" guard at
+once (see `scripts/lib/lock.rb`, the write-guard comment). A zero-byte
+`*.write.lock` in a completed intent directory is by design; no cleaner may
+sweep it, and it is already inside the store's `*.lock` gitignore rule.
+(Intent 317a, A2: a review misread it as stale residue and nearly shipped
+the sweep.)

package/skills/intent-ending/SKILL.md

@@ -63,11 +63,14 @@ 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`. 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
+fill `## Summary`, `## Delivered`, `## Verification`, `## Follow-ups`. `## Delivered` is a
+`| Row | What |` table: one row per thing delivered, in plain wording a reader
+recognizes, not a method name or an implementation summary (that detail
+belongs in `## Summary`). Each row's label must appear as a standalone token
+in an action-file heading (`### S1 - ...` proves row S1); that heading's
+matrix rows become the row's Proven-by cell on `report-screen delivered`'s
+post-delivery screen. `## Needs you` is the literal None or a
+`| N | What | Why |` table. 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/templates/outcome.md

@@ -8,13 +8,21 @@ disposition: delivered|abandoned
 
 ## Delivered
 <!-- One row per thing delivered, in plain wording a reader recognizes, not
-an implementation summary; the technical detail belongs in ## Summary. -->
-- ...
+an implementation summary; the technical detail belongs in ## Summary. Each
+row's label must appear as a standalone token in an actions/*.md heading
+(for example "### S1 - ..." proves row S1): that heading's matrix rows become
+the row's Proven-by cell on the delivered screen (intent 317 D19, 317a). -->
+| Row | What |
+| --- | --- |
+| S1 | ... |
 
 ## Verification
 - <acceptance criterion> — verified by ... → result
 
 ## Needs you
+<!-- The literal None, or a table shaped | N | What | Why | with one row per
+open owner action. Prose is tolerated by the reader but renders as a single
+untyped row - write the table. -->
 None
 
 ## Follow-ups