@zalom/plastic 1.14.1 → 2.0.0-alpha.10

package/scripts/lib/screen_paint.rb

@@ -0,0 +1,276 @@
+# 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
+
+  # Intent 317a1 (D3, D4, D5): the data-table palette. Kind and note columns
+  # are chosen by the table's own header, never by position; a cell whose
+  # text is exactly "not recorded" greys wherever it appears.
+  EVIDENCE_PROOF_KINDS = %w[suite red ship doctor deposits verdict].freeze
+  EVIDENCE_DEVIATION_KINDS = %w[deviates].freeze
+  NOTE_HEADERS = %w[Source Why].freeze
+  NOT_RECORDED = "not recorded"
+
+  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
+    indent_run = 0
+
+    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)
+      # Intent 317a1 (O6, D8): the run counter tracks consecutive :indented
+      # lines so only the SECOND and later lines under a heading like
+      # "**Asked**" grey as a note; a :table line (which `next`s below) must
+      # reset it too, so a later unrelated indented block starts fresh.
+      indent_run = kind == :indented ? indent_run + 1 : 0
+      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
+        text = A.fit_plain(clean(line.chomp, markdown_safe), width)
+        out << (indent_run > 1 ? A.styled(text, color, A::MIDGREY) : text) << "\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
+        # Intent 317a1 (O5, D6, D7): the time carries no escape at all; the
+        # kind label carries the color - amber for the review turning point,
+        # teal for a landed commit, mid-grey (no bold) otherwise.
+        m = TIMELINE_RE.match(line.chomp)
+        codes = case m[2]
+                when "Review" then [A::BOLD, A::AMBER]
+                when "Commit" then [A::BOLD, A::TEAL]
+                else [A::MIDGREY]
+                end
+        out << m[1] << "  " << A.styled(m[2].ljust(6), color, *codes) << "  " << 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 three-column field block: bold key,
+  # value, and a mid-grey note that shares the line when it fits, dropping
+  # to its own line only as a fallback (D9-D11). 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?("**")
+      return paint_field_table(rows, color: color, width: width, markdown_safe: markdown_safe)
+    end
+
+    paint_data_table(rows, color: color, markdown_safe: markdown_safe)
+  end
+
+  # Intent 317a1 (O3, D9-D11, D14, D15): the same three-column geometry as
+  # IntentScreenAnsi.render's field-row loop, on the SAME implementation
+  # (D12) - `IntentScreenAnsi.field_table_lines` - so the two renderers
+  # cannot drift apart. Notes arrive as plain text here, so `visible_width`
+  # equals `length`, but the shared helper is used anyway so both renderers
+  # read identically.
+  def paint_field_table(rows, color:, width:, markdown_safe:)
+    key_w = rows.map { |r| cells_of(r).first.to_s.gsub("*", "").length }.max
+    field_rows = rows.map do |row|
+      key, value, note = cells_of(row)
+      key = key.to_s.gsub("*", "")
+      [key, clean(value.to_s, markdown_safe), clean(note.to_s, markdown_safe)]
+    end
+    A.field_table_lines(field_rows, width: width, color: color, key_width: key_w)
+  end
+
+  # Intent 317a1 (O4, D3-D5): a data table's kind and note columns are chosen
+  # by the header, never by position; a cell whose text is exactly "not
+  # recorded" greys wherever it appears. `widths[ci] || 0` (rather than a
+  # bare `widths[ci]`) is the ragged-row guard: `ReportScreen.escape` writes
+  # `\|` while `cells_of` still splits on every `|`, so a row can carry more
+  # cells than its header without either side ever raising.
+  def paint_data_table(rows, color:, markdown_safe:)
+    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 }
+    kind_col = grid.first.first == "Kind" ? 0 : nil
+    note_col = grid.first.index { |h| NOTE_HEADERS.include?(h) }
+
+    out = +""
+    grid.each_with_index do |cols, ri|
+      last_ci = cols.length - 1
+      cells = cols.each_with_index.map do |cell, ci|
+        padded = ci == last_ci ? cell.to_s : cell.to_s.ljust(widths[ci] || 0)
+        # An empty cell never gets styled (317a1 post-exec review, finding
+        # 1): `A.styled("", ...)` still emits a color-open/RESET pair around
+        # nothing visible, and that hides the join separator's own trailing
+        # spaces from `.rstrip` below, on the very line the reader sees.
+        next padded if cell.to_s.empty?
+        if ri.zero?
+          A.styled(padded, color, A::BOLD)
+        elsif ci == kind_col && EVIDENCE_PROOF_KINDS.include?(cell)
+          A.styled(padded, color, A::TEAL, A::BOLD)
+        elsif ci == kind_col && EVIDENCE_DEVIATION_KINDS.include?(cell)
+          A.styled(padded, color, A::AMBER, A::BOLD)
+        elsif ci == note_col
+          A.styled(padded, color, A::MIDGREY)
+        elsif cell == "done"
+          A.styled(padded, color, A::TEAL)
+        elsif cell == "open"
+          A.styled(padded, color, A::AMBER)
+        elsif cell == NOT_RECORDED
+          A.styled(padded, color, A::MIDGREY)
+        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/lib/session_backfill.rb

@@ -0,0 +1,184 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# SessionBackfill (intent 301): file a session day ledger. The four backfilled
+# documents are a pure function of the day's checklist.md and savepoint.md, so
+# every run regenerates them in full and a rerun is correct by construction.
+# The carry step deduplicates against the target day before it appends and
+# flips the source line after, so a crash at any point leaves a rerun correct.
+# Every ledger write goes through SessionLedger. No environment reads here;
+# the CLI passes every path in.
+
+require "date"
+require "fileutils"
+require "time"
+require_relative "session_ledger"
+
+module SessionBackfill
+  module_function
+
+  DOCS = ["spec.md", "plan.md", "actions/ACTION_1.md", "outcome.md"].freeze
+  SAVEPOINT_RE = /\A(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z)\s{2,}(\S+)(?:\s{2,}(.*))?\z/m.freeze
+  CARRIED_RE = / \(carried from \d{8}\)\z/.freeze
+  FILER_SESSION = "filer"
+  FILER_PROJECT = "global"
+  SUMMARY_CAP = 200
+
+  # --- reading ---------------------------------------------------------------
+
+  def parse_savepoint_line(line)
+    match = SAVEPOINT_RE.match(line.to_s.chomp.scrub)
+    return nil unless match
+
+    { timestamp: match[1], event: match[2], rest: match[3].to_s }
+  end
+
+  def read_items(dir)
+    path = File.join(dir, "checklist.md")
+    SessionLedger.read_locked(path).each_line.filter_map { |l| SessionLedger.parse_checklist_line(l) }
+  end
+
+  def read_savepoint_lines(dir)
+    path = File.join(dir, "savepoint.md")
+    SessionLedger.read_locked(path).each_line.map(&:chomp).reject(&:empty?)
+  end
+
+  # --- rendering, pure ---------------------------------------------------------
+
+  def format_item(item)
+    marker = SessionLedger::STATES.fetch(item[:state])
+    "- [#{marker}] [#{item[:session]}] [#{item[:project]}] #{item[:summary]}"
+  end
+
+  def section(title, lines)
+    body = lines.empty? ? "(none)" : lines.join("\n")
+    "## #{title}\n#{body}\n"
+  end
+
+  def render(dir, day:)
+    items = read_items(dir)
+    steps = read_savepoint_lines(dir)
+    requests = items.reject { |i| i[:state] == :dropped }.map { |i| "- [#{i[:session]}] [#{i[:project]}] #{i[:summary]}" }
+    done = items.select { |i| i[:state] == :done }.map { |i| format_item(i) }
+    carried = items.select { |i| i[:state] == :moved }.map { |i| format_item(i) }
+    promoted = items.select { |i| i[:state] == :promoted }.map { |i| format_item(i) }
+    disposition = done.empty? ? "abandoned" : "delivered"
+
+    {
+      "spec.md" => "# Spec: session ledger #{day}\n\n#{section('Requests', requests)}",
+      "plan.md" => "# Plan: session ledger #{day}\n\n#{section('Steps', steps.map { |s| "- #{s}" })}",
+      "actions/ACTION_1.md" => "# ACTION_1: session ledger #{day}\n\n#{section('Items', items.map { |i| format_item(i) })}",
+      "outcome.md" => "---\ndisposition: #{disposition}\n---\n# Outcome: session ledger #{day}\n\n" \
+                      "#{section('Delivered', done)}\n#{section('Carried', carried)}\n#{section('Promoted', promoted)}",
+    }
+  end
+
+  # --- writing, atomic inside the day dir ----------------------------------------
+
+  def write_atomic(dir, relative, content)
+    target = File.join(dir, relative)
+    FileUtils.mkdir_p(File.dirname(target))
+    tmp = File.join(File.dirname(target), ".filing-#{File.basename(target)}")
+    File.write(tmp, content)
+    File.rename(tmp, target)
+  end
+
+  def write_docs(dir, docs)
+    docs.each { |relative, content| write_atomic(dir, relative, content) }
+  end
+
+  # --- closed marker ---------------------------------------------------------------
+
+  def closed_at(day_file)
+    return nil unless File.exist?(day_file)
+
+    frontmatter = File.read(day_file).split(/^---\s*$/, 3)[1].to_s
+    value = frontmatter[/^closed:\s*(\S+)/, 1]
+    value ? Time.iso8601(value) : nil
+  rescue ArgumentError
+    nil
+  end
+
+  def stamp_closed(day_file, now:)
+    stamp = "closed: #{now.utc.strftime('%Y-%m-%dT%H:%M:%SZ')}\n"
+    content = File.read(day_file)
+    updated =
+      if content =~ /^closed:.*\n/
+        content.sub(/^closed:.*\n/, stamp)
+      else
+        parts = content.split(/^(---\s*\n)/, 3)
+        # parts: ["", "---\n", frontmatter, "---\n", rest]
+        parts.length >= 4 ? parts[0] + parts[1] + parts[2] + stamp + parts[3] + parts[4].to_s : content + stamp
+      end
+    write_atomic(File.dirname(day_file), File.basename(day_file), updated)
+  end
+
+  # A day is closed when it carries a closed: stamp and its checklist has not
+  # been written since (integer-second comparison; a line appended within the
+  # closing second waits for the next line).
+  def closed?(store, day)
+    closed = closed_at(SessionLedger.day_file(store, day))
+    return false unless closed
+
+    checklist = SessionLedger.checklist_path(store, day)
+    return true unless File.exist?(checklist)
+
+    File.mtime(checklist).to_i <= closed.to_i
+  end
+
+  # --- carry -------------------------------------------------------------------------
+
+  def carried_summary(summary, from)
+    suffix = " (carried from #{from})"
+    base = SessionLedger.sanitize_summary(summary.sub(CARRIED_RE, ""))
+    room = SUMMARY_CAP - suffix.length
+    base = "#{base[0, room - 3]}..." if base.length > room
+    base + suffix
+  end
+
+  def note(store, day, text, now:)
+    SessionLedger.append_line(SessionLedger.savepoint_path(store, day),
+                              SessionLedger.savepoint_line("Note", FILER_SESSION, FILER_PROJECT, text, now: now))
+  end
+
+  def carry(store:, from:, to:, templates:, author:, now: Time.now)
+    SessionLedger.open_day(store: store, day: to, templates: templates, author: author, now: now)
+    source = SessionLedger.checklist_path(store, from)
+    target = SessionLedger.checklist_path(store, to)
+    existing = read_items(SessionLedger.day_dir(store, to)).map { |i| [i[:session], i[:summary]] }
+    count = 0
+    read_items(SessionLedger.day_dir(store, from)).select { |i| i[:state] == :open }.each do |item|
+      summary = carried_summary(item[:summary], from)
+      unless existing.include?([item[:session], summary])
+        SessionLedger.append_line(target, SessionLedger.checklist_line(:open, item[:session], item[:project], summary),
+                                  header: SessionLedger.checklist_header(to))
+        existing << [item[:session], summary]
+      end
+      SessionLedger.set_state(source, from: :open, to: :moved, session: item[:session], match: item[:summary])
+      count += 1
+    end
+    return 0 if count.zero?
+
+    note(store, from, "carried #{count} items to #{to}", now: now)
+    note(store, to, "received #{count} items from #{from}", now: now)
+    count
+  end
+
+  # --- the filer -----------------------------------------------------------------------
+
+  # Returns :closed when the day is already filed and unchanged, else :filed.
+  def file_day(store:, day:, templates:, author:, carry_to: nil, now: Time.now)
+    SessionLedger.open_day(store: store, day: day, templates: templates, author: author, now: now)
+    return :closed if closed?(store, day)
+
+    dir = SessionLedger.day_dir(store, day)
+    checklist = SessionLedger.checklist_path(store, day)
+    dropped = SessionLedger.flip_all(checklist, from: :pending, to: :dropped)
+    note(store, day, "dropped #{dropped} pending lines at filing", now: now) if dropped.positive?
+    carry(store: store, from: day, to: carry_to, templates: templates, author: author, now: now) if carry_to
+    write_docs(dir, render(dir, day: day))
+    stamp = [Time.now, (File.exist?(checklist) ? File.mtime(checklist) : Time.at(0))].max
+    stamp_closed(SessionLedger.day_file(store, day), now: stamp)
+    :filed
+  end
+end

package/scripts/lib/session_close.rb

@@ -0,0 +1,104 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# SessionClose (intent 301): the per-session close, run by hooks/close at
+# SessionEnd. Cheap, fail-open, and a no-op for the reasons that do not end a
+# session (`clear`, `resume`). Every job runs in its own rescue so one failure
+# never stops the next. No environment reads; the hook script passes the
+# store, today's day id, and the spawner in.
+
+require "fileutils"
+require_relative "session_ledger"
+require_relative "handoff"
+
+module SessionClose
+  module_function
+
+  NOOP_REASONS = %w[clear resume].freeze
+
+  # The default hand-off writer (intent 311, spec D6): renders this session's
+  # share of the pointer day into handoff--<session>.md before the tmp dir
+  # goes. The hook script builds it with the shipped templates dir.
+  def default_handoff(templates)
+    lambda do |store, day, session|
+      Handoff.write(store: store, day: day, session: session, trigger: "close", templates: templates)
+    end
+  end
+
+  # The default spawner starts the day filer detached so a slow filing never
+  # blocks the harness shutdown (Codex kills a SessionEnd hook after 3 s).
+  def default_spawner(script)
+    lambda do |args|
+      pid = Process.spawn({ "RUBYOPT" => nil }, RbConfig.ruby, script, *args,
+                          pgroup: true, in: File::NULL, out: File::NULL, err: File::NULL)
+      Process.detach(pid)
+    end
+  end
+
+  # Returns a small report hash; never raises.
+  def run(payload:, store:, today:, spawner:, handoff: nil, now: Time.now)
+    report = { reason: nil, dropped: 0, removed_tmp: false, spawned: nil, handoff: false }
+    reason = payload.is_a?(Hash) ? payload["reason"].to_s : ""
+    report[:reason] = reason
+    return report if NOOP_REASONS.include?(reason)
+
+    session = SessionLedger.short_session_id(payload.is_a?(Hash) ? payload["session_id"] : nil, nil)
+    return report if session.empty?
+
+    pointer_day = safely { read_pointer_day(store, session) } || today
+    project = "global"
+
+    report[:dropped] = safely do
+      checklist = SessionLedger.checklist_path(store, pointer_day)
+      count = SessionLedger.flip_all(checklist, from: :pending, to: :dropped, session: session)
+      if count.positive?
+        SessionLedger.append_line(SessionLedger.savepoint_path(store, pointer_day),
+                                  SessionLedger.savepoint_line("Note", session, project,
+                                                               "dropped #{count} pending lines at close", now: now))
+      end
+      count
+    end || 0
+
+    # The hand-off (intent 311, spec D6) is written after the drop, so it
+    # reflects it, and before the tmp dir goes, since the pointer lives there.
+    # An intent pointer falls back to today, the same as the drop above.
+    if handoff
+      report[:handoff] = safely do
+        handoff.call(store, pointer_day, session)
+        true
+      end || false
+    end
+
+    report[:removed_tmp] = safely do
+      dir = SessionLedger.session_tmp_dir(store, session)
+      FileUtils.rm_rf(dir) if Dir.exist?(dir)
+      true
+    end || false
+
+    if pointer_day < today
+      report[:spawned] = safely do
+        args = ["--day", pointer_day, "--carry-to", today, "--store", store]
+        spawner.call(args)
+        args
+      end
+    end
+    report
+  end
+
+  # The pointer names the intent this session records into; a day id means
+  # the day ledger. Anything else (an intent id) means an auto team owns the
+  # record and the close touches no day ledger.
+  def read_pointer_day(store, session)
+    path = SessionLedger.pointer_path(store, session)
+    return nil unless File.exist?(path)
+
+    value = File.read(path).strip
+    SessionLedger.valid_day_id?(value) ? value : nil
+  end
+
+  def safely
+    yield
+  rescue StandardError
+    nil
+  end
+end