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

package/agents/plastic-enforcer.md

@@ -31,7 +31,9 @@ deliberately; the auto pipeline never dispatches them.
    `plastic-intent-executing`'s `plan-reviewer-prompt.md`; fold every finding into the spec, the
    matrix, and the tests.
 4. **Dispatch one executor, tests first** - the executor commits the matrix's tests red, then
-   builds, then drives the full suite green; you verify the checklist against the diff.
+   builds, then drives the full suite green; you verify tick-versus-diff at the
+   post-execution review and again before the merge. A mismatch is a review finding, not a
+   cleanup you perform silently.
 5. **Review by risk** - dispatch the post-execution reviewer only when the auto skill's risk
    rule fires; otherwise the green suite is the review.
 6. **Close** - `outcome.md`, then `plastic-intent-ending`, which releases the worktree, clears

package/agents/plastic-executor.md

@@ -20,7 +20,11 @@ valid lifecycle artifacts. Honor it as your live state; do not re-derive or cont
    any other change.
 2. **Implement the actions** - make the code changes for each action in order, inside the
    worktree the preamble names.
-3. **Track progress** - check off `checklist.md` items as they complete.
+3. **Tick with the commit** - commit after each logical unit of work, and in the same step
+   tick the checklist item that unit lands: mark its box `[x]` and move the line to
+   `## Completed`, then append the savepoint `Commit` line
+   (`scripts/savepoint-note <intent_dir> --kind Commit --text "<sha> <what it proves>"`). A
+   commit without its tick is incomplete.
 4. **Record insights** - capture durable discoveries and report them in the `insights:` field;
    persist each to `## Insights` via the `insight-append` helper
    (`scripts/insight-append <intent_dir> <text> --stage Exec --author "plastic-executor (autonomous)"`),
@@ -33,7 +37,8 @@ valid lifecycle artifacts. Honor it as your live state; do not re-derive or cont
    real `ACTION_N.md` with its failure-mode matrix, pasted in by the lead. Execute the action
    files in order.
 2. Write the matrix's tests; commit red.
-3. Work one action at a time, preferring safe, non-destructive routes.
+3. Work one action at a time, ticking its checklist item in the same commit that lands it
+   (box marked, line moved); prefer safe, non-destructive routes.
 4. Run the full suite, iterate to zero failures and zero errors; commit green.
 5. Produce (output handoff): the code changes, a checked-off `checklist.md`, and `## Insights`.
 6. Report (see `## Completion Report`); the lead applies the risk rule and may dispatch a
@@ -46,7 +51,8 @@ preamble's `REPORT_CONTRACT` and `skills/auto/references/agent-report-contract.m
 finish silently. Carry the common envelope (role, intent id, stage, status, artifacts written,
 verification, checklist deltas, deviations, blockers, insights) plus the executor payload:
 
-- Actions implemented this turn, mapped to checklist items checked off (checked / total)
+- Actions implemented this turn, mapped to checklist items checked off (checked / total);
+  checked / total must equal the items whose commits exist
 - A summary of the code changed (files and the shape of the change)
 - Test result: the red commit's failing count, then the full-suite command and its pass / fail
   counts

package/hooks/statusline

@@ -2,8 +2,8 @@
 # plastic-hook-version: 4.0.0
 # StatusLine hook - Plastic owns the full statusline (no chaining).
 # Renders: {model} - ctx {pct}% ({used}/{size}) - 5h {p}% - 7d {p}% - ${cost}
-#          - claudish {n} rw / {tok} - Plastic {version}[ -> {next}] - {path}
-# Every segment but claudish and the Plastic version comes from the stdin payload.
+#          - Plastic {version}[ -> {next}] - {path}
+# Every segment but the Plastic version comes from the stdin payload.
 # Pure bash (macOS 3.2 compatible). No ruby, no jq. Reads stdin once; small file reads
 # only. The stdin JSON is walked in a single awk pass (below); nothing else in this
 # script forks a second process per field, which is what keeps a render cheap.
@@ -17,7 +17,6 @@ C_OK=''                             # default   - meter below 70%
 C_WARN=$'\033[33m'                  # yellow    - meter at 70% and above
 C_CRIT=$'\033[38;2;231;76;60m'      # red       - meter at 90% and above
 C_COST=$'\033[37m'                  # white     - session cost
-C_CLAUDISH=$'\033[38;2;249;140;30m' # orange    - claudish rewrites
 C_VER=$'\033[37m'                   # white     - "Plastic {version}" and update arrow
 C_NEXT=$'\033[33m'                  # yellow    - next version
 C_PATH=$'\033[38;2;128;134;144m'    # gray      - path (matches dim UI text)
@@ -309,40 +308,18 @@ if [ -n "$COST_RAW" ]; then
   [ -n "$COST_FMT" ] && [ "$COST_FMT" != "0.00" ] && COST_SEG="${C_COST}\$${COST_FMT}${RST}"
 fi
 
-# --- claudish rewrites for THIS session (fork ledger, optional) ---
-# Tab separated, one call per line; column 11 is the session id. Rows written
-# before that column existed have 9 or 10 fields and never match, so an old
-# ledger renders no segment instead of a wrong one.
-CL_SEG=""
-CL_LOG="${CLAUDISH_LOCAL_DIR:-$HOME/.claude/claudish-local}/usage.log"
-if [ -n "$SID" ] && [ -f "$CL_LOG" ]; then
-  CL=$(awk -F'\t' -v sid="$SID" '
-    NF >= 11 && $11 == sid { n++; t += $5 + $6 }
-    END {
-      if (n > 0) {
-        if (t >= 1000) {
-          s = sprintf("%.1f", t / 1000); sub(/\.0$/, "", s); printf "%d %sk", n, s
-        } else {
-          printf "%d %d", n, t
-        }
-      }
-    }' "$CL_LOG" 2>/dev/null)
-  [ -n "$CL" ] && CL_SEG="${C_CLAUDISH}claudish ${CL%% *} rw / ${CL#* }${RST}"
-fi
-
 # --- Assemble segments in order, joined by " . " ---
 PARTS=""
 add() { [ -z "$1" ] && return; if [ -z "$PARTS" ]; then PARTS="$1"; else PARTS="$PARTS$SEP$1"; fi; }
 
-# Order: identity first (model), then this session's spend (context, meters, cost,
-# rewrites), then the volatile-length values last (version, path) so the line does
+# Order: identity first (model), then this session's spend (context, meters, cost),
+# then the volatile-length values last (version, path) so the line does
 # not visually jump as they change.
 [ -n "$MODEL" ] && add "${C_MODEL}${MODEL}${RST}"
 add "$CTX_SEG"
 add "$M5"
 add "$M7"
 add "$COST_SEG"
-add "$CL_SEG"
 if [ -n "$VERSION" ]; then
   vseg="${C_VER}Plastic ${VERSION}${RST}"
   [ -n "$NEXT" ] && vseg="${vseg}${C_VER} "$'\342\206\222'" ${RST}${C_NEXT}${NEXT}${RST}"

package/package.json

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

package/scripts/doctor.rb

@@ -30,6 +30,7 @@ require_relative "lib/power_tools"
 require_relative "lib/preflight"
 require_relative "lib/ruby_probe"
 require_relative "lib/doctor_session_ledger"
+require_relative "lib/intent_screen"
 
 # Diagnostic engine, instantiable with an injected store/agent map so tests can
 # run it hermetically (no eval, no global-constant rewriting).
@@ -1161,9 +1162,11 @@ end
   #
   # Doctor's fourth check scope, invoked by `--intent <id>`. Never a store-wide sweep:
   # resolves exactly one intent directory (mirrors scripts/end-intent's resolve_intent_dir /
-  # scripts/project-links's --intent disambiguation) and returns five checks, four
-  # FAIL-severity, one WARN-severity (intent_savepoint_truthful stays WARN per intent 134's
-  # binding advisory-only ruling; see spec.md D2/D8 - do NOT escalate it to FAIL).
+  # scripts/project-links's --intent disambiguation) and returns six checks, four
+  # FAIL-severity, two WARN-severity: intent_savepoint_truthful stays WARN per intent 134's
+  # binding advisory-only ruling (see spec.md D2/D8 - do NOT escalate it to FAIL), and
+  # intent_ticks_lag is WARN-only per intent 329's ruling that a lagging tick warns rather
+  # than blocks.
   def check_intent_end(id, store: nil, disposition: nil)
     intent_dir, scope = resolve_single_intent_dir(id, store: store)
     unless intent_dir
@@ -1185,6 +1188,7 @@ end
       intent_structure_check(intent_dir),
       intent_lifecycle_artifacts_check(intent_dir, disposition),
       intent_checklist_complete_check(intent_dir),
+      intent_ticks_lag_check(intent_dir),
       intent_links_projection_check_for(id, scope),
       intent_savepoint_truthful_check(intent_dir, index_path: index_path),
     ]
@@ -1263,6 +1267,45 @@ end
     end
   end
 
+  # Intent 329: the checklist is the only input to the state screen's Progress bar, so an
+  # intent whose commit ledger has entries and whose checklist has no ticked item is
+  # reporting 0 progress on work that already landed. Advisory only (WARN), like
+  # intent_savepoint_truthful: a lagging tick is a lead's review finding, never a machine
+  # refusal. The commit count comes from this intent's own savepoint.md Commit ledger
+  # (intent 317 D17), never from git: git's detected base is the repo default branch, which
+  # is not the base a 2.0 intent branch forks from.
+  def intent_ticks_lag_check(intent_dir)
+    items = IntentScreen.checklist_items(intent_dir)
+    if items.empty?
+      return check(category: "intent_end", name: "intent_ticks_lag", status: "pass",
+                   message: "n/a: checklist.md has no items to tick")
+    end
+
+    ticked = items.count { |i| i[:done] }
+    commits = savepoint_commit_count(intent_dir)
+
+    if commits.positive? && ticked.zero?
+      check(category: "intent_end", name: "intent_ticks_lag", status: "warn",
+            message: "ticks lag the branch: #{commits} commit(s) recorded, " \
+                     "0 of #{items.size} checklist items ticked")
+    else
+      check(category: "intent_end", name: "intent_ticks_lag", status: "pass",
+            message: "#{ticked} of #{items.size} ticked, #{commits} commit(s) recorded")
+    end
+  end
+
+  # Count `Commit` lines in the intent's savepoint ledger, through the one regex that parses
+  # a savepoint line (IntentScreen::SAVEPOINT_RE; field 2 is the kind).
+  def savepoint_commit_count(intent_dir)
+    path = File.join(intent_dir, "savepoint.md")
+    return 0 unless File.exist?(path)
+
+    File.readlines(path).count do |line|
+      m = line.strip.match(IntentScreen::SAVEPOINT_RE)
+      m && m[2] == "Commit"
+    end
+  end
+
   def intent_links_projection_check_for(id, scope)
     ctx = build_links_projection_context
     node = ctx[:intents].find { |n| n[:id] == id && n[:scope] == scope }

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/scripts/verify-intent

@@ -15,7 +15,8 @@
 # other flags exist.
 #
 # Checks, all run every invocation (the fourth only when --suite is given):
-#   1. doctor    - Doctor#run_intent_check(id, store: scope), fail-open on a crash
+#   1. doctor    - Doctor#run_intent_check(id, store: scope), fail-open on a crash; the doctor
+#                  scan includes the intent_ticks_lag warning (intent 329)
 #   2. em-dash   - added lines only of `git diff <base>...HEAD`, never the whole tree
 #   3. diffstat  - `git diff --stat <base>...HEAD`, never a failure on its own
 #   4. suite     - the supplied --suite command, run with RUBYOPT cleared

package/skills/auto/SKILL.md

@@ -217,7 +217,7 @@ Then Exec.
    then builds, then drives the full suite green.
 2. Read its return by code: DONE or DONE_WITH_CONCERNS proceeds; NEEDS_CONTEXT re-dispatches
    with the missing context; BLOCKED stops under the error procedure.
-3. Tick the checklist as items land (the executor does this; verify it).
+3. Tick the checklist as items land (the executor does this); verify tick-versus-diff against the diff. A mismatch is a review finding, not a lead cleanup.
 
 ## Review by risk (boot 3, only when a rule fires)
 
@@ -254,7 +254,7 @@ 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.
+1. This is the merge gate: verify every checklist item is checked, verify tick-versus-diff against the diff, and confirm the suite is green once on the branch.
 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
@@ -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

package/skills/intent-executing/SKILL.md

@@ -108,11 +108,15 @@ Capture observations in `## Insights`. When ALL checklist items are checked:
 
 ## Tick-as-you-land
 
-As each task lands, in the same edit: move its checklist item from `## In
-Progress` to `## Completed` in `checklist.md`, and add one `## Session Log`
-row (Date, Items Completed, Notes). Do not batch several tasks' worth of
-checklist updates into one later edit; tick the moment the task is verified,
-before moving to the next task.
+A tick is two edits, made together: mark the item's box `[x]`, and move its
+checklist item from `## In Progress` to `## Completed` in `checklist.md`;
+then add one `## Session Log` row (Date, Items Completed, Notes). The box is
+the half the state screen's Progress bar reads: `IntentScreen::ITEM_RE` and
+`progress_fields` count `[x]`, not which section the line sits in, so a line
+moved to `## Completed` with its box left unmarked still reads as zero
+progress. Do not batch several tasks' worth of checklist updates into one
+later edit; tick the moment the task is verified, before moving to the next
+task.
 
 ## Verify before every owner review
 

package/skills/intent-executing/implementer-prompt.md

@@ -20,12 +20,17 @@ You are implementing a specific task from a plan. You have been given the full t
 2. Implement exactly what the task specifies — nothing more, nothing less.
 3. Write tests first when the task includes test steps (TDD).
 4. Follow the file paths specified in the task exactly.
-5. Commit after each logical unit of work.
+5. Commit after each logical unit of work, and in the same step tick the checklist item that
+   unit lands: mark its box `[x]` and move the line to `## Completed`, then append the
+   savepoint `Commit` line
+   (`scripts/savepoint-note <intent_dir> --kind Commit --text "<sha> <what it proves>"`). A
+   commit without its tick is incomplete.
 6. When done, self-review against this checklist:
    - [ ] All steps in the task are completed
    - [ ] Tests pass
    - [ ] Code is clean and follows project conventions
    - [ ] No unrelated changes
+   - [ ] Every landed unit's checklist item is ticked
 
 ## Report Format