@zalom/plastic 2.0.0-alpha.12 → 2.0.0-alpha.13

package/package.json

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

package/scripts/lib/report_screen.rb

@@ -10,8 +10,10 @@
 # renderer path as `renderer_path:` (D2).
 require "time"
 require "json"
+require "date"
 require_relative "intent_screen"
 require_relative "lock"
+require_relative "session_ledger"
 
 module ReportScreen
   NOT_RECORDED = "not recorded"
@@ -73,10 +75,52 @@ module ReportScreen
     Array(frontmatter(intent_dir)["tags"]).map(&:to_s).include?("research")
   end
 
+  # Intent 330 (D12): the shared fence walker feeding split_by_headings AND
+  # table_rows. A line matching \A\s{0,3}(```+|~~~+) while closed opens a
+  # fence and remembers the marker character and its length; while open, a
+  # line whose marker is the SAME character and at least as long, with only
+  # whitespace after it, closes the fence. Inside a fence every line is body
+  # - a leading "#" or a leading "|" included. A four-space-indented block is
+  # deliberately never a fence (the cap is 0-3 leading whitespace chars),
+  # which is the CommonMark indented-code case, out of scope on purpose
+  # (D12's stated limit). Yields [line, fenced] for every line, in order.
+  FENCE_LINE_RE = /\A\s{0,3}(`{3,}|~{3,})/.freeze
+
+  def self.each_fence_line(text)
+    return enum_for(:each_fence_line, text) unless block_given?
+
+    marker = nil # [character, length] of the currently open fence, or nil
+    text.to_s.each_line do |line|
+      if marker
+        yield line, true
+        m = line.match(FENCE_LINE_RE)
+        next unless m && m[1][0] == marker[0] && m[1].length >= marker[1]
+        next unless line.sub(FENCE_LINE_RE, "").strip.empty?
+
+        marker = nil
+      else
+        m = line.match(FENCE_LINE_RE)
+        if m
+          marker = [m[1][0], m[1].length]
+          yield line, true
+        else
+          yield line, false
+        end
+      end
+    end
+  end
+
   # Markdown pipe-table data rows (header + separator skipped), each an array
-  # of trimmed cell strings. Tolerates leading prose before the table.
+  # of trimmed cell strings. Tolerates leading prose before the table. Fence-
+  # aware (D12/O1.7): a pipe row inside a fenced example is never counted.
   def self.table_rows(text)
-    lines = text.to_s.lines.map(&:strip).select { |l| l.start_with?("|") }
+    lines = []
+    each_fence_line(text) do |line, fenced|
+      next if fenced
+
+      stripped = line.strip
+      lines << stripped if stripped.start_with?("|")
+    end
     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 }
@@ -84,13 +128,14 @@ module ReportScreen
 
   # 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.
+  # are never confused with a sibling section's. Fence-aware (D12): a "#"
+  # line inside a fenced example never starts a new section.
   def self.split_by_headings(text)
     sections = []
     heading = nil
     body = +""
-    text.to_s.each_line do |line|
-      if line.start_with?("#")
+    each_fence_line(text) do |line, fenced|
+      if !fenced && line.start_with?("#")
         sections << [heading, body] if heading
         heading = line.strip
         body = +""
@@ -327,13 +372,64 @@ module ReportScreen
     line && line.match(/\b([0-9a-f]{7,40})\b/)[1]
   end
 
-  def self.ship_row(_text, intent_dir, tag_reader)
+  # Intent 330 (D9): reads `flow: base:` from a project's project.yml when
+  # `intent_dir` sits in the installed project layout
+  # (<home>/projects/<slug>/store/<id--slug>); nil otherwise (a global-store
+  # intent, a project with no `flow:` key, or malformed YAML). Pure: no git,
+  # no shell-out, just the one file this intent's own layout already reads.
+  PROJECT_LAYOUT_RE = %r{\A(.*)/projects/([^/]+)/store/[^/]+\z}.freeze
+
+  def self.flow_base(intent_dir)
+    m = intent_dir.to_s.match(PROJECT_LAYOUT_RE)
+    return nil unless m
+
+    home, slug = m[1], m[2]
+    path = File.join(home, "projects", slug, "project.yml")
+    return nil unless File.exist?(path)
+
+    require "yaml"
+    data = YAML.safe_load(File.read(path))
+    return nil unless data.is_a?(Hash)
+
+    flow = data["flow"]
+    return nil unless flow.is_a?(Hash)
+
+    base = flow["base"]
+    base.is_a?(String) && !base.empty? ? base : nil
+  rescue StandardError
+    nil
+  end
+
+  # Intent 330 (D9/D10/D23): the ship row's WHAT cell is the merge sha, then
+  # " → <branch>" only when `branch_reader` answers one (never the "alpha"
+  # literal), then " · v<version>" or the existing not-recorded fallback. The
+  # Source cell names WHERE the branch came from (D23): project.yml when
+  # flow_base itself supplied that exact branch, else git refs, so the row
+  # never keeps the stale "git tags" literal for a branch git never answered.
+  def self.ship_row(_text, intent_dir, tag_reader, branch_reader: ->(_dir) { nil })
     sha = merge_sha(intent_dir)
     version = shipped_version(intent_dir) || 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
+    branch = branch_reader.call(intent_dir)
     sha_text = sha || NOT_RECORDED
-    { kind: "ship", what: "#{sha_text} → alpha · #{ver_text}", source: "outcome.md; git tags" }
+    what = +sha_text
+    what << " → #{branch}" if branch && !branch.to_s.empty?
+    # D10: the version segment is omitted, not filled with NOT_RECORDED. A
+    # repository with no release line has no version, the header already
+    # carries the shipped identity, and naming the absence twice on one screen
+    # is the defect this intent was opened to remove, not a floor worth keeping.
+    what << " · v#{version.to_s.sub(/\Av/, '')}" if version && !version.to_s.empty?
+    # D14: the cell names every file the row actually came from. The branch and
+    # the version have different origins, so when both contributed, both are
+    # named rather than only the branch's.
+    sources = ["outcome.md"]
+    if branch && !branch.to_s.empty?
+      sources << (flow_base(intent_dir) == branch ? "project.yml" : "git refs")
+    end
+    sources << "git tags" if version && !version.to_s.empty? && shipped_version(intent_dir).nil?
+    sources << "git tags" if sources.length == 1
+    source = sources.join("; ")
+    { kind: "ship", what: what, source: source }
   end
 
   def self.doctor_row(text)
@@ -362,7 +458,7 @@ module ReportScreen
     { kind: "verdict", what: m[1].strip, source: "outcome.md" }
   end
 
-  def self.evidence_rows(intent_dir, tag_reader: ->(_dir) { nil })
+  def self.evidence_rows(intent_dir, tag_reader: ->(_dir) { nil }, branch_reader: ->(_dir) { nil })
     text = outcome_text(intent_dir)
     return [] unless text
     verification = section_of(text, "## Verification")
@@ -370,7 +466,7 @@ module ReportScreen
     rows = []
     rows << suite_row(verification)
     rows << red_row(verification)
-    rows << (research_intent?(intent_dir) ? nil : ship_row(text, intent_dir, tag_reader))
+    rows << (research_intent?(intent_dir) ? nil : ship_row(text, intent_dir, tag_reader, branch_reader: branch_reader))
     if research_intent?(intent_dir)
       rows << deposits_row(text)
       rows << verdict_row(text)
@@ -444,7 +540,11 @@ module ReportScreen
 
   # --- roster (D7/D8) -------------------------------------------------------------
 
-  def self.active_dirnames(index_path)
+  # The dirnames named under one "## <section_name>" heading of an INDEX.md.
+  # active_dirnames used to hardcode "Active"; intent 330's session verb (D22)
+  # reuses this to find Completed/Abandoned dirnames for the no-bookend
+  # footer, so the section is now a parameter.
+  def self.dirnames_in_section(index_path, section_name)
     return [] unless File.exist?(index_path)
     dirnames = []
     section = nil
@@ -453,13 +553,24 @@ module ReportScreen
         section = line[3..].strip
         next
       end
-      next unless section == "Active"
+      next unless section == section_name
       m = line.match(%r{\(store/([^/]+)/})
       dirnames << m[1] if m
     end
     dirnames
   end
 
+  def self.active_dirnames(index_path)
+    dirnames_in_section(index_path, "Active")
+  end
+
+  # Intent 330 (D22): both terminal sections count as "completed" for the
+  # no-bookend footer - a closed intent the reader cannot expect a Done
+  # savepoint line from, since the convention predates end-intent writing it.
+  def self.completed_dirnames(index_path)
+    dirnames_in_section(index_path, "Completed") + dirnames_in_section(index_path, "Abandoned")
+  end
+
   def self.newest_savepoint_ts(intent_dir)
     lines = savepoint_lines(intent_dir)
     lines.last&.first
@@ -541,18 +652,31 @@ module ReportScreen
     done ? human_time(done[0]) : NOT_RECORDED
   end
 
-  def self.render_delivered(intent_dir:, tag_reader: ->(_dir) { nil })
+  # Intent 330 (D11): the header's last segment is the shipped identity, and
+  # says which kind it is - v<version> when a version is known, else
+  # "merge <sha>" (never a bare, ambiguous hash), else the exact NOT_RECORDED
+  # string when neither exists.
+  def self.header_ship_segment(intent_dir, tag_reader)
+    version = shipped_version(intent_dir) || tag_reader.call(intent_dir)
+    return "v#{version.to_s.sub(/\Av/, '')}" if version && !version.to_s.empty?
+
+    sha = merge_sha(intent_dir)
+    return "merge #{sha}" if sha && !sha.to_s.empty?
+
+    NOT_RECORDED
+  end
+
+  def self.render_delivered(intent_dir:, tag_reader: ->(_dir) { nil }, branch_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 = shipped_version(intent_dir) || tag_reader.call(intent_dir)
-    ver_text = version && !version.to_s.empty? ? "v#{version.to_s.sub(/\Av/, '')}" : NOT_RECORDED
+    ship_segment = header_ship_segment(intent_dir, tag_reader)
 
     lines = []
     lines << "## ✔ #{id} · #{name} · delivered"
-    lines << "#{ts} · #{m} · #{dur} · #{ver_text}"
+    lines << "#{ts} · #{m} · #{dur} · #{ship_segment}"
     lines << ""
     lines << "**Asked**"
     lines << "  #{asked(intent_dir)}"
@@ -566,7 +690,7 @@ module ReportScreen
     end
     lines << ""
     lines << "**Evidence**"
-    ev = evidence_rows(intent_dir, tag_reader: tag_reader)
+    ev = evidence_rows(intent_dir, tag_reader: tag_reader, branch_reader: branch_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
@@ -661,6 +785,184 @@ module ReportScreen
     "#{lines.join("\n")}\n"
   end
 
+  # --- S9: the session verb (intent 330) -------------------------------------------
+  #
+  # `report-screen session <tier_root>` - the delivered screens for every intent
+  # this session completed, oldest first, then the state --all roster (D1).
+  # Membership is the savepoint Done bookend inside [window_start, now] (D2),
+  # never the delivery lock (a dispatched lead's derived auto- key is not the
+  # owner's session id). The pure functions below take the clock and the
+  # ledger root as arguments (D8): no Time.now, no git, no ENV read here.
+
+  # <home> for a tier root, by the same layout discriminator IntentScreen
+  # uses elsewhere: a project tier root's parent directory is "projects".
+  def self.home_for_tier_root(tier_root)
+    File.basename(File.dirname(tier_root)) == "projects" ? File.expand_path("../..", tier_root) : tier_root
+  end
+
+  # D18: <home>/store/.sessions, derived from the tier root through the SAME
+  # discriminator - deriving it unconditionally from tier_root would answer
+  # "/Users" for the global tier (~/.plastic itself has no "store" segment
+  # to strip).
+  def self.default_ledger_root(tier_root)
+    File.join(home_for_tier_root(tier_root), "store", ".sessions")
+  end
+
+  # D5: "global" is <home> itself; any other slug is <home>/projects/<slug>.
+  def self.store_for_slug(home, slug)
+    slug == "global" ? home : File.join(home, "projects", slug)
+  end
+
+  # D4: the newest valid day directory that is not in the future, when
+  # `today`'s own day directory does not exist. No ledger at all (D3.13)
+  # answers `today` unchanged rather than raising - there is simply nothing
+  # to scan, not an error.
+  def self.fallback_day(ledger_root, today)
+    return today if Dir.exist?(File.join(ledger_root, today))
+    return today unless Dir.exist?(ledger_root)
+
+    candidates = Dir.children(ledger_root).select { |d| SessionLedger.valid_day_id?(d) && d <= today }
+    candidates.max || today
+  end
+
+  # D17: the visible note printed above the screens when no session id was
+  # given at all, so the whole-day, tier-only fallback never looks like a
+  # real, narrower answer.
+  # D17: shaped as a screen opener ("▶ ... · ...") on purpose. The note is the
+  # first line of the reply, and both ScreenPaint's OPENER_RE and the
+  # MessageDisplay hook's first-character gate require that shape; a plain
+  # sentence here would leave the whole session report unpainted.
+  def self.window_note(day, reason)
+    "▶ Window · the whole of #{Date.strptime(day, '%Y%m%d').iso8601} · #{reason}"
+  end
+
+  # True when the day ledger actually carries a line for this session, across
+  # the same two day directories the window search reads. The CLI asks so it
+  # can tell "no session id given" apart from "this session id matches no
+  # ledger line": D17 exists to stop the second one answering silently, and a
+  # resumed background job carries exactly that kind of unmatched id.
+  def self.session_tagged?(ledger_root:, session:, now:)
+    return false if session.nil? || session.to_s.strip.empty?
+
+    short = SessionLedger.short_session_id(session)
+    today = SessionLedger.day_id(now)
+    yesterday = SessionLedger.day_id(now - 86_400)
+    [yesterday, today].any? do |d|
+      session_ledger_lines(ledger_root, d).any? { |l| l[:session] == short }
+    end
+  end
+
+  # D4: local midnight of `day`, converted to UTC, using `sample_now`'s OWN
+  # utc_offset - never a literal UTC midnight, and never the machine's
+  # ambient zone outside what the injected clock itself carries.
+  def self.local_midnight_utc(day, sample_now)
+    date = Date.strptime(day, "%Y%m%d")
+    Time.new(date.year, date.month, date.day, 0, 0, 0, sample_now.utc_offset)
+  end
+
+  # One day's session-tagged savepoint lines: "{ts}  {Event}  [{session}]
+  # [{slug}] {summary}" (SessionLedger.savepoint_line's own shape). Missing
+  # file, or a line that does not match, is silently skipped.
+  SESSION_LEDGER_LINE_RE = /\A(\d{4}-\d\d-\d\dT\d\d:\d\d:\d\dZ)\s{2,}\S+\s{2,}\[([^\]]*)\]\s\[([^\]]*)\]/.freeze
+
+  def self.session_ledger_lines(ledger_root, day)
+    path = File.join(ledger_root, day, "savepoint.md")
+    return [] unless File.exist?(path)
+
+    File.readlines(path).filter_map do |line|
+      m = line.match(SESSION_LEDGER_LINE_RE)
+      m ? { ts: m[1], session: m[2], slug: m[3] } : nil
+    end
+  end
+
+  def self.store_intent_dirs(store)
+    Dir.glob(File.join(store, "store", "*")).select { |d| IntentScreen.intent_dir?(d) }
+  end
+
+  def self.last_done_ts(intent_dir)
+    lines = savepoint_lines(intent_dir)
+    done = lines.reverse.find { |_ts, kind, _text| kind == "Done" }
+    done ? Time.parse(done[0]) : nil
+  end
+
+  # D2/D3/D4/D5/D22: the intent directories completed inside the session's
+  # window, oldest Done bookend first, plus the count of completed intents
+  # (D22: Completed or Abandoned in INDEX.md) that carry no Done bookend at
+  # all and so cannot be placed in any window.
+  def self.session_delivered_dirs(ledger_root:, tier_root:, session:, since:, now:)
+    today = SessionLedger.day_id(now)
+    yesterday = SessionLedger.day_id(now - 86_400)
+    short = session && !session.to_s.strip.empty? ? SessionLedger.short_session_id(session) : nil
+
+    tagged = short ? [yesterday, today].flat_map { |d| session_ledger_lines(ledger_root, d) }
+                         .select { |l| l[:session] == short } : []
+    slugs = tagged.map { |l| l[:slug] }.uniq
+
+    window_start =
+      if since
+        Time.parse(since.to_s)
+      elsif tagged.any?
+        tagged.map { |l| Time.parse(l[:ts]) }.min
+      else
+        local_midnight_utc(fallback_day(ledger_root, today), now)
+      end
+
+    home = home_for_tier_root(tier_root)
+    stores = ([tier_root] + slugs.map { |s| store_for_slug(home, s) }).uniq
+    stores = stores.select { |s| File.exist?(File.join(s, "INDEX.md")) }
+
+    entries = []
+    skipped = 0
+    stores.each do |store|
+      completed = completed_dirnames(File.join(store, "INDEX.md"))
+      store_intent_dirs(store).each do |dir|
+        done_ts = last_done_ts(dir)
+        if done_ts
+          entries << [dir, done_ts] if done_ts >= window_start && done_ts <= now
+        elsif completed.include?(File.basename(dir))
+          skipped += 1
+        end
+      end
+    end
+
+    [entries.sort_by { |_dir, ts| ts }.map(&:first), skipped]
+  end
+
+  # D1/D7/D21/D22: one delivered screen per directory (oldest first, one
+  # blank line apart), the roster last, and the skipped-count footer between
+  # them when non-zero. `painter` is applied to each block SEPARATELY (D21):
+  # a screen ScreenPaint cannot parse falls back to its own plain text
+  # without touching its neighbours; the default is the identity function,
+  # so a caller that never paints gets the plain screens verbatim. A
+  # directory whose delivered screen cannot be rendered (O3.28) never sinks
+  # the rest of the report.
+  def self.render_session(dirs:, skipped:, store_root:, tag_reader: ->(_dir) { nil },
+                           branch_reader: ->(_dir) { nil }, note: nil, changed: nil,
+                           now: Time.now, painter: ->(text) { text })
+    blocks = []
+    blocks << note if note && !note.to_s.empty?
+
+    if dirs.empty?
+      blocks << "No intents delivered in this session."
+    else
+      dirs.each do |dir|
+        blocks << begin
+          render_delivered(intent_dir: dir, tag_reader: tag_reader, branch_reader: branch_reader).chomp
+        rescue StandardError => e
+          "## #{intent_id(dir)} · could not render (#{e.message})"
+        end
+      end
+    end
+
+    if skipped.positive?
+      blocks << "#{skipped} completed intent#{skipped == 1 ? '' : 's'} skipped: no Done bookend in savepoint.md."
+    end
+
+    blocks << render_roster(store_root, changed: changed, now: now).chomp
+
+    "#{blocks.map { |b| painter.call(b) }.join("\n\n")}\n"
+  end
+
   # --- S8: --ansi passthrough (D2) -----------------------------------------------
   #
   # 316a owns the ANSI renderer; 317 only wires a generic DI seam so this

package/scripts/lib/screen_paint.rb

@@ -56,7 +56,7 @@ module ScreenPaint
     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)
+    return :closer if ["None", "not recorded", "No intents in delivery.", "No intents delivered in this session."].include?(stripped)
     :unknown
   end
 
@@ -101,7 +101,10 @@ module ScreenPaint
     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
+    # Intent 330 (D7/O3.26): a screen that is nothing but a single known
+    # closer line (e.g. "No intents delivered in this session.") has no
+    # opener to require - it is already the whole, honest message.
+    return nil unless %i[opener closer].include?(classify(lines[first_idx]))
 
     out = +""
     table = []

package/scripts/lib/session_ledger.rb

@@ -29,6 +29,10 @@ module SessionLedger
 
   SESSIONS_DIR = ".sessions"
   TMP_DIR = ".tmp"
+  # Named here, not in a CLI, so a caller can reference the key without the
+  # literal harness-branded env var name appearing in its own source (a few
+  # scripts are guarded against naming a harness at all).
+  SESSION_ID_ENV_KEY = "CLAUDE_CODE_SESSION_ID"
   DAY_ID = /\A\d{8}\z/
   EVENTS = %w[Item Done Note]
   STATES = { pending: "~", open: " ", done: "x", moved: ">", dropped: "-", promoted: "^" }.freeze

package/scripts/report-screen

@@ -2,15 +2,19 @@
 # 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.
+# report-screen - the four delivery-report screens: mid-delivery state,
+# post-delivery delivered, and delay (intent 317), plus session, the whole of
+# one session's delivered work followed by the roster (intent 330). 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] [--repo <dir>]
 #   report-screen delay <intent_dir> [--ansi]
+#   report-screen session <tier_root> [--session <id>] [--since <iso>]
+#                                     [--ledger-root <dir>] [--ansi]
 #
 # --ansi delegates to ScreenPaint (intent 317a, D1), the parser/re-layouter
 # in the shared TUI core. Selection is by capability, never by harness:
@@ -28,6 +32,7 @@ require "shellwords"
 require_relative "lib/report_screen"
 require_relative "lib/intent_screen"
 require_relative "lib/screen_paint"
+require_relative "lib/session_ledger"
 
 def usage_abort(message)
   warn "report-screen: #{message}"
@@ -39,10 +44,13 @@ end
 # on the delivered screen is the release that merge shipped in. The
 # repository comes from --repo, else from projects.yml beside the store (the
 # installed layout, <home>/projects/<slug>/store/<id>), else the repository
-# this script lives in (the in-repo layout). No merge sha, no repository, or
-# no containing tag all answer nil, and the screen says "not recorded"
-# rather than guessing from HEAD (D14). The pure module never reads git.
-def resolve_repo(intent_dir, explicit_repo, script_dir)
+# this script lives in (the in-repo layout, `include_self: true`) - unless
+# `include_self: false` (the branch reader, D23), in which case a global
+# intent's repo never falls back to the script's own repository, since that
+# is not the intent's repository at all. No merge sha, no repository, or no
+# containing tag all answer nil, and the screen says "not recorded" rather
+# than guessing from HEAD (D14). The pure module never reads git.
+def resolve_repo(intent_dir, explicit_repo, script_dir, include_self: true)
   candidates = []
   candidates << File.expand_path(explicit_repo) if explicit_repo
   if (m = intent_dir.match(%r{\A(.*)/projects/([^/]+)/store/[^/]+\z}))
@@ -59,7 +67,7 @@ def resolve_repo(intent_dir, explicit_repo, script_dir)
       candidates << File.expand_path(path) unless path.empty?
     end
   end
-  candidates << File.expand_path("..", script_dir)
+  candidates << File.expand_path("..", script_dir) if include_self
   candidates.find { |c| File.exist?(File.join(c, ".git")) }
 end
 
@@ -78,12 +86,39 @@ def git_tag_reader(explicit_repo:, script_dir:)
   end
 end
 
+# D9/D23: the injected branch reader. flow_base (a pure YAML read, never
+# git) wins when the intent's project names a flow base; otherwise the
+# repository's remote HEAD, else whichever of main/master exists. Resolves
+# the repo with `include_self: false` (D23): a global-store intent must
+# never fall back to the script's OWN repository (~/.plastic itself, on
+# "main" in the installed layout) and print a confident, wrong branch.
+def git_branch_reader(explicit_repo:, script_dir:)
+  lambda do |intent_dir|
+    flow = ReportScreen.flow_base(intent_dir)
+    next flow if flow && !flow.to_s.empty?
+
+    repo = resolve_repo(intent_dir, explicit_repo, script_dir, include_self: false)
+    next nil unless repo
+
+    branch = `git -C #{repo.shellescape} symbolic-ref --short refs/remotes/origin/HEAD 2>/dev/null`.strip
+    branch = branch.sub(%r{\Aorigin/}, "")
+    next branch unless branch.empty?
+
+    %w[main master].find do |b|
+      system("git", "-C", repo, "rev-parse", "--verify", "--quiet", b, out: File::NULL, err: File::NULL)
+    end
+  end
+end
+
 args = ARGV.dup
 verb = args.shift
 changed = nil
 ansi = false
 template_path = nil
 repo_flag = nil
+session_flag = nil
+since_flag = nil
+ledger_root_flag = nil
 positional = []
 
 while (arg = args.shift)
@@ -99,13 +134,19 @@ while (arg = args.shift)
     repo_flag = args.shift or usage_abort("--repo needs a path")
   when "--template"
     template_path = args.shift or usage_abort("--template needs a path")
+  when "--session"
+    session_flag = args.shift or usage_abort("--session needs a value")
+  when "--since"
+    since_flag = args.shift or usage_abort("--since needs a value")
+  when "--ledger-root"
+    ledger_root_flag = args.shift or usage_abort("--ledger-root 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
+usage_abort("usage: report-screen state|delivered|delay|session <intent_dir> [--changed \"<text>\"] [--ansi]") unless verb
 
 all_mode = positional.delete("--all") ? true : false
 target = positional.first
@@ -142,7 +183,8 @@ when "delivered"
   intent_dir = File.expand_path(target)
   usage_abort("#{intent_dir} is not an intent directory") unless IntentScreen.intent_dir?(intent_dir)
   out = ReportScreen.render_delivered(intent_dir: intent_dir,
-                                      tag_reader: git_tag_reader(explicit_repo: repo_flag, script_dir: __dir__))
+                                      tag_reader: git_tag_reader(explicit_repo: repo_flag, script_dir: __dir__),
+                                      branch_reader: git_branch_reader(explicit_repo: repo_flag, script_dir: __dir__))
   $stdout.write paint(out, ansi_enabled)
 when "delay"
   usage_abort("usage: report-screen delay <intent_dir>") unless target
@@ -150,8 +192,49 @@ when "delay"
   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)
+when "session"
+  usage_abort("usage: report-screen session <tier_root> [--session <id>] [--since <iso>] [--ledger-root <dir>] [--ansi]") 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"))
+
+  now = Time.now
+  session_id = session_flag || ENV[SessionLedger::SESSION_ID_ENV_KEY]
+  ledger_root = ledger_root_flag ? File.expand_path(ledger_root_flag) : ReportScreen.default_ledger_root(store_root)
+
+  if since_flag
+    begin
+      Time.parse(since_flag)
+    rescue ArgumentError
+      usage_abort("--since needs an ISO timestamp, got #{since_flag.inspect}")
+    end
+  end
+
+  dirs, skipped = ReportScreen.session_delivered_dirs(ledger_root: ledger_root, tier_root: store_root,
+                                                       session: session_id, since: since_flag, now: now)
+  # D17: the widened window is announced whether the id was missing or simply
+  # matched nothing. A resumed background job carries a session id that is not
+  # the one on the ledger lines, and that case must not answer silently. An
+  # explicit --since is the caller naming the window, so it needs no note.
+  note =
+    if since_flag
+      nil
+    elsif session_id.nil? || session_id.to_s.strip.empty?
+      ReportScreen.window_note(ReportScreen.fallback_day(ledger_root, SessionLedger.day_id(now)),
+                               "no session id given")
+    elsif !ReportScreen.session_tagged?(ledger_root: ledger_root, session: session_id, now: now)
+      ReportScreen.window_note(ReportScreen.fallback_day(ledger_root, SessionLedger.day_id(now)),
+                               "this session has no line in the day ledger")
+    end
+
+  out = ReportScreen.render_session(
+    dirs: dirs, skipped: skipped, store_root: store_root,
+    tag_reader: git_tag_reader(explicit_repo: nil, script_dir: __dir__),
+    branch_reader: git_branch_reader(explicit_repo: nil, script_dir: __dir__),
+    note: note, now: now, painter: ->(text) { paint(text, ansi_enabled) }
+  )
+  $stdout.write out
 else
-  usage_abort("unknown verb #{verb.inspect} (use state|delivered|delay)")
+  usage_abort("unknown verb #{verb.inspect} (use state|delivered|delay|session)")
 end
 
 exit 0

package/skills/auto/SKILL.md

@@ -272,13 +272,14 @@ Read `../plastic-conventions/references/completion-and-done.md` for what "intent
      --session "$CLAUDE_CODE_SESSION_ID" \
      --index-note "<what shipped>; <suite result>"
    ```
-   Exit 4 means a live foreign session holds the lock; 5 means the worktree is dirty (commit
-   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. Print it as the first thing in
-   the reply, nothing before it and no code fence, or the hook cannot paint it.
+   Exit 4: a live foreign session holds the lock. 5: the worktree is dirty (commit first, or
+   pass `--discard-worktree-changes` deliberately). 3: the lock survived the disarm
+   (`/plastic-doctor check the lock status`). 6: 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): the owner
+   report at End, replacing the old prose Done briefing. A mid-batch status ask instead runs
+   `report-screen session <tier_root> --session "$CLAUDE_CODE_SESSION_ID"` (intent 330). Print
+   it as the first thing in the reply, no code fence, or the hook cannot paint it.
 
 ## Error Handling
 

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

@@ -14,6 +14,10 @@ written by eye:
   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.
+- **`report-screen session <tier_root>`** - the answer to an UNNAMED status ask ("where are we
+  with delivery", "what is the status"): one `delivered` screen per intent this session
+  completed, oldest first, then the `state --all` roster. Intent 330's ruling: a status ask
+  answers with what actually shipped, not the in-flight roster alone.
 
 ## The five triggers for `state`
 

package/skills/intent-continuing/SKILL.md

@@ -111,11 +111,15 @@ For a live intent's directory:
    `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
+   `ruby ~/.plastic/scripts/report-screen session <tier_root> --session <this session's id>`
+   (intent 330; pass the id your harness gives you, or the screen widens to the whole day and
+   says so): it prints one
+   `delivered` screen per intent this session actually completed, oldest first, then the same
+   roster `report-screen state --all <store_root>` prints on its own - `state --all` stays the
+   right call when only the in-flight roster is wanted, with nothing delivered above it. 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. Then continue the work in the