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

package/scripts/report-screen

@@ -2,15 +2,21 @@
 # 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
+# report-screen - the pre-delivery plan (intent 331b), the four delivery
+# reports: 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 plan <intent_dir> [--ansi]
 #   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]
+#   report-screen roadmap <roadmap.md> plan|state|delivered [--ansi] [--store-root <dir>]
 #
 # --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 +34,14 @@ require "shellwords"
 require_relative "lib/report_screen"
 require_relative "lib/intent_screen"
 require_relative "lib/screen_paint"
+require_relative "lib/session_ledger"
+
+# Intent 331a (D6/R8): every caller-added screen kind file registers itself
+# on load (ScreenPaint.register), so this glob is the ONLY wiring a new kind
+# needs - no edit here, no edit to screen_paint.rb. Sorted for a
+# deterministic load order; tolerates the directory being absent or empty
+# (Dir.glob answers [] either way), which is this repo's own state today.
+Dir.glob(File.join(__dir__, "lib", "screens", "*.rb")).sort.each { |f| require_relative f }
 
 def usage_abort(message)
   warn "report-screen: #{message}"
@@ -39,10 +53,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 +76,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 +95,40 @@ 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
+store_root_flag = nil
 positional = []
 
 while (arg = args.shift)
@@ -99,13 +144,21 @@ 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")
+  when "--store-root"
+    store_root_flag = args.shift or usage_abort("--store-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 plan|state|delivered|delay|session <intent_dir> [--changed \"<text>\"] [--ansi]") unless verb
 
 all_mode = positional.delete("--all") ? true : false
 target = positional.first
@@ -119,6 +172,16 @@ def paint(text, ansi_enabled, _renderer_path = nil)
 end
 
 case verb
+when "plan"
+  usage_abort("usage: report-screen plan <intent_dir> [--ansi]") unless target
+  intent_dir = File.expand_path(target)
+  usage_abort("#{intent_dir} is not an intent directory") unless IntentScreen.intent_dir?(intent_dir)
+  store_root = File.expand_path("../..", intent_dir)
+  template_path ||= File.expand_path("../templates/report-plan.md", __dir__)
+  usage_abort("template not found at #{template_path}") unless File.exist?(template_path)
+  out = ReportScreen.render_plan(intent_dir: intent_dir, store_root: store_root,
+                                  template: File.read(template_path))
+  $stdout.write paint(out, ansi_enabled)
 when "state"
   if all_mode
     usage_abort("usage: report-screen state --all <store_root>") unless target
@@ -142,7 +205,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 +214,61 @@ 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
+when "roadmap"
+  usage_abort("usage: report-screen roadmap <roadmap.md> plan|state|delivered [--ansi] [--store-root <dir>]") if positional.empty?
+  roadmap_path = File.expand_path(positional[0])
+  usage_abort("#{roadmap_path} does not exist") unless File.exist?(roadmap_path)
+  sub_verb = positional[1]
+  usage_abort("usage: report-screen roadmap <roadmap.md> plan|state|delivered") unless sub_verb
+  unless %w[plan state delivered].include?(sub_verb)
+    usage_abort("unknown sub-verb #{sub_verb.inspect} (use plan|state|delivered)")
+  end
+  roadmap_store_root = store_root_flag ? File.expand_path(store_root_flag) : nil
+  out = ReportScreen.render_roadmap(path: roadmap_path, verb: sub_verb, store_root: roadmap_store_root)
+  $stdout.write paint(out, ansi_enabled)
 else
-  usage_abort("unknown verb #{verb.inspect} (use state|delivered|delay)")
+  usage_abort("unknown verb #{verb.inspect} (use plan|state|delivered|delay|session|roadmap)")
 end
 
 exit 0

package/scripts/savepoint-note

@@ -2,15 +2,16 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-# savepoint-note - the writer CLI for the two savepoint kinds intent 317 adds:
-# Review (one line per plan-review or post-execution-review verdict) and
-# Commit (one line per commit landing during Exec). D17: there is no automatic
-# seam for either (session-commit writes the day ledger, not the intent
-# ledger; the executor's own commits are plain git), so this is an explicit
-# thin wrapper on Savepoint.append_review_savepoint / append_commit_savepoint.
+# savepoint-note - the writer CLI for three savepoint kinds: Review (one line per
+# plan-review or post-execution-review verdict) and Commit (one line per commit landing
+# during Exec), both from intent 317, D17; and Report (one line per report screen printed,
+# intent 331f). None has an automatic seam (session-commit writes the day ledger, not the
+# intent ledger; the executor's own commits are plain git; a printed screen is a skill's own
+# reply, not a file write), so this is an explicit thin wrapper on
+# Savepoint.append_review_savepoint / append_commit_savepoint / append_report_savepoint.
 #
 # Usage:
-#   savepoint-note <intent_dir> --kind Review|Commit --text "<text>"
+#   savepoint-note <intent_dir> --kind Review|Commit|Report --text "<text>"
 #
 # --text is normalized (D21): runs of two or more spaces collapse to one, so a
 # free-text kind that happens to contain a double space cannot key the dedup
@@ -46,12 +47,12 @@ while (arg = args.shift)
   end
 end
 
-usage_abort("usage: savepoint-note <intent_dir> --kind Review|Commit --text \"<text>\"") unless positional.length == 1
+usage_abort("usage: savepoint-note <intent_dir> --kind Review|Commit|Report --text \"<text>\"") unless positional.length == 1
 
 intent_dir = File.expand_path(positional.first)
 usage_abort("#{intent_dir} is not an intent directory") unless File.exist?(Savepoint.intent_file(intent_dir))
 
-KINDS = %w[Review Commit].freeze
+KINDS = %w[Review Commit Report].freeze
 usage_abort("--kind must be one of #{KINDS.join(', ')}, got #{kind.inspect}") unless KINDS.include?(kind)
 usage_abort("--text is required") if text.nil? || text.empty?
 usage_abort("--text must not contain a newline") if text.include?("\n")
@@ -62,6 +63,7 @@ usage_abort("--text is empty after normalization") if normalized.empty?
 case kind
 when "Review" then Savepoint.append_review_savepoint(intent_dir, normalized)
 when "Commit" then Savepoint.append_commit_savepoint(intent_dir, normalized)
+when "Report" then Savepoint.append_report_savepoint(intent_dir, normalized)
 end
 
 exit 0

package/skills/auto/SKILL.md

@@ -201,11 +201,9 @@ Then How.
    into the spec, the matrix, and the tests; record what was dropped and why in the action
    file's review fold. A REVISE verdict is folded and not re-reviewed unless a finding changes
    a decision.
-5. Print `ruby ~/.plastic/scripts/report-screen state <intent_dir> --changed "How written, plan review next"`
-   (D15; see `references/human-report-contract.md` for the full trigger list). This replaces
-   the old prose State/Risk/Call briefing at this boundary. In auto mode the screen informs;
-   it does not wait. The screen opens the reply with nothing before it and no code fence: the
-   `MessageDisplay` hook paints only a reply whose first characters are the screen marker.
+5. Print `ruby ~/.plastic/scripts/report-screen plan <intent_dir>` as the first characters of
+   the reply, nothing before it, no fence, before dispatching the executor (see
+   `references/human-report-contract.md` for the full binding table). It informs; it does not wait.
 
 Then Exec.
 
@@ -272,13 +270,16 @@ 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/331f), and
+   `report-screen state` at each of the five triggers in `references/human-report-contract.md`
+   (a review verdict, a blocker, a merge/release, or an owner status ask; a mid-batch ask
+   instead runs `report-screen session <tier_root> --session "$CLAUDE_CODE_SESSION_ID"`, intent
+   330). Print each as the first characters of the reply: nothing before it, no fence, or the
+   hook cannot paint it.
 
 ## Error Handling
 

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

@@ -1,9 +1,12 @@
-# Human Report Contract (the three report screens, intent 317)
+# Human Report Contract (the report screens, intent 317)
 
 D15: the prose EM-to-CTO briefing this doc used to define is retired. The orchestrator now
-prints one of three report screens, filled from the record by `scripts/report-screen`, never
+prints one of these report screens, filled from the record by `scripts/report-screen`, never
 written by eye:
 
+- **`report-screen plan <intent_dir>`** - the pre-delivery report (intent 331b), printed once
+  at the How boundary, before the executor is dispatched: Asked, Decisions, Steps, Mode,
+  Reviewer, then the Steps table (Step, Action, What) and the Risks table.
 - **`report-screen state <intent_dir> [--changed "<text>"]`** - the mid-delivery report. One
   intent's field table (Store, Status, Stage, Savepoint, Progress, Next, Insight) plus a
   `Changed` row naming what caused the print, and its Steps table.
@@ -14,6 +17,59 @@ 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.
+- **`dashboard.rb continue|project <slug> --screen`** - the dashboard screen (intent 331d):
+  Active, In delivery, Delivered, Roadmap, Sessions, Changed, then the Where-we-are and
+  Where-we-go-next tables. A separate script from the other four (`dashboard.rb`, not
+  `report-screen`), since it aggregates across a whole store or project rather than one
+  intent; it prints on `continue` and on loading a project, not as a delivery trigger.
+
+## Binding table (intent 331f)
+
+Every skill that shows state names its own report verb, one row per skill and trigger. Each
+bound skill's file carries the SAME rule next to its verb: print the screen as the first
+characters of the reply, nothing before it, no fence, or the hook cannot paint it.
+
+| Skill | Trigger | Verb |
+|---|---|---|
+| `plastic-intent-continuing` | project route (continue, load project) | `dashboard.rb ... --screen` |
+| `plastic-intent-continuing` | a named intent | `report-screen state` |
+| `plastic-intent-continuing` | "where are we" (a status ask) | `report-screen session` |
+| `plastic-intent-continuing` | "why so long" | `report-screen delay` |
+| `plastic-intent-continuing` | a roadmap route | `report-screen roadmap ... state` |
+| `plastic-auto` | the How boundary, before the executor | `report-screen plan` |
+| `plastic-auto` | each of the five triggers | `report-screen state` |
+| `plastic-auto` | close | `report-screen delivered` |
+| `plastic-intent-ending` | the close | `report-screen delivered` |
+| `plastic-intent-speccing` | the action files are written | `report-screen plan` |
+| `plastic-roadmap` | create | `report-screen roadmap ... plan` |
+| `plastic-roadmap` | read | `report-screen roadmap ... state` |
+| `plastic-roadmap` | close | `report-screen roadmap ... delivered` |
+| `plastic-dashboard` | any invocation | `dashboard.rb ... --screen` |
+| `plastic-intent-executing` | after the red commit, and after the suite | `report-screen state` |
+
+## A roadmap's own three reports (intent 331c)
+
+A roadmap gets the same pre-, in-, and post-delivery shape as an intent, through
+`report-screen roadmap <roadmap.md> plan|state|delivered [--ansi] [--store-root <dir>]`:
+
+- **`roadmap plan`** - the pre-delivery report: the Goal's first sentence, the batch (or legacy
+  wave) count and intent count, the batch order, and when the roadmap was created; then the
+  full entries table.
+- **`roadmap state`** - the in-delivery report: Goal, a Progress bar over intents delivered of
+  intents total (never batches), the frontier batch, who is delivering it and their lead, the
+  next queued entry, and the last ledger event; then the entries table with each entry's own
+  checklist progress and lead.
+- **`roadmap delivered`** - the post-delivery report: a meta line (closed time, or `in progress`
+  when the goal is not yet reached; intent count; duration) directly under the title, the
+  delivered table with each entry's merge sha, and the `## Log` table.
+
+Every cell traces to the roadmap file, `INDEX.md` (which always wins on status), the roadmap's
+own savepoint ledger, or (falling back when no ledger file exists) the roadmap's `## Log` -
+never a second parser: `RoadmapQueue`'s own public `roadmap` reader supplies every entry.
 
 ## The five triggers for `state`
 
@@ -38,9 +94,9 @@ on harness name to decide.
 
 ## Depth for small work
 
-For small work in auto mode, only the How-boundary `state` screen prints mid-flight (its
-`Changed` row names what the What and Why steps did, since there is no separate briefing per
-stage any more). Larger work prints `state` at every trigger in the table above. This is a
+For small work in auto mode, only the How-boundary `plan` screen prints mid-flight (intent
+331f moved this print off `state`, since there is no separate briefing per stage any more).
+Larger work prints `state` at every trigger in the table above. This is a
 depth cut, not a different report: the screen's shape never changes, only how often it fires.
 A delivery still ends with `outcome.md` plus one `delivered` screen.
 
@@ -73,6 +129,25 @@ In guided mode, `state` prints at each stage boundary and the human decides befo
 stage starts.
 
 In auto mode, `state` prints at every trigger for larger work; for small work only the How
-boundary prints (see `## Depth for small work` above). The orchestrator takes the go-ahead
-itself and moves on, except at the existing hard stops (destructive action without a safe
-alternative, project-path confirm).
+boundary's `plan` screen prints (see `## Depth for small work` above). The orchestrator takes
+the go-ahead itself and moves on, except at the existing hard stops (destructive action without
+a safe alternative, project-path confirm).
+
+## Column vocabulary (D5, intent 331f)
+
+Owner ruling 2026-09-05 11:05 UTC: "What" is never a column name, because What is a stage, not
+a value. The id column reads `Graph ID`; the title column reads `Intent`. Every Steps table
+reads `Step | Status | Detail` (the plan screen's own Steps table reads
+`Step | Action | Detail`); every Risks table reads `N | Risk`; the Delivered/Evidence/Needs-you
+tables on the `delivered` screen read `Row | Detail | Proven by`, `Kind | Detail | Source`, and
+`N | Need | Reason`. The plan screen's Asked row prints the intent title before its first
+colon, never the whole intent line. This applies to every screen the family prints: `state`,
+`roster`, `session`, `delivered`, `delay`, `plan`, `roadmap` (`plan`/`state`/`delivered`), and
+`dashboard`. `outcome.md`'s own `| Row | What |` heading is an AUTHORING convention inside the
+file a human writes, never a rendered header, and stays unchanged.
+
+## Width bound (D7, intent 331f)
+
+No rendered row passes 115 visible columns. A long cell (the roadmap Goal, an intent title, an
+Asked line) truncates on a word boundary with a single ellipsis; `ReportScreen.fit_screen`
+shrinks a table's widest column first, floor 8, before it ever truncates a whole row.

package/skills/dashboard/SKILL.md

@@ -7,7 +7,8 @@ user-invocable: false
 # Dashboard — Plastic Work Cockpit
 
 A deterministic overview of the intent store(s). It answers three questions at a glance:
-**where we are** (recently worked), **where we go next** (the most-valuable next work), and
+**where we are** (recently worked; `Graph ID | Intent | Stage | Progress | Lead`),
+**where we go next** (the most-valuable next work; `Rank | Graph ID | Intent | Reason`), and
 **how to conduct it** (a disposition per intent). The human-facing surface is **Markdown**,
 because the user's UI renders Markdown natively but collapses raw tool-call stdout.
 
@@ -22,6 +23,16 @@ state → byte-identical payload, regardless of model. Do NOT hand-summarize int
 - `plastic-intent-continuing` lands on the board on a bare resume
 - `plastic-auto` reads `--json` to choose the next dispatchable intent
 
+## The screen surface (intent 331d/331f)
+
+`dashboard.rb project <slug> --screen` (or `continue --screen` for the global board) is the
+default surface on every invocation: print it as the first characters of the reply, nothing
+before it, no fence, or the hook cannot paint it. It carries a title, six fields (Active, In
+delivery, Delivered, Roadmap, Sessions, Changed), then the Where-we-are and Where-we-go-next
+tables, its own grammar and painted form standing in for the filled Markdown template below.
+`plastic-intent-continuing`'s project route prints it this way. The Markdown board (Step 1-4
+below) stays available as the deeper prose surface a reader can ask for.
+
 ## Procedure (the Markdown board — default human surface)
 
 ### Step 1 — Get the data payload
@@ -70,7 +81,7 @@ Fill mechanically, no rewriting, no re-sorting:
   re-truncate, or reword them. Never emit `<br>`.
   - `next_work` → `| {id} | {what} | {value} | {disposition} | {flags_label} |`
   - `active` → `| {id} | {what} | {stage} | {worker} | {activity} |`
-  Empty list → one full-width row with `_(none)_` in the Id column and every other cell blank,
+  Empty list → one full-width row with `_(none)_` in the Graph ID column and every other cell blank,
   matching that table's column count (e.g. `| _(none)_ | | | | |` for the 5-column next_work
   table, `| _(none)_ | | | |` for the 5-column active table). Neither list carries an overflow
   "+N more" row anymore (D5, intent 202): the true pool size rides on the payload as

package/skills/dashboard/templates/dashboard-global.md

@@ -11,7 +11,7 @@
 
 ## Most-valuable next work
 
-| Id | What | Value | Disposition | Flags |
+| Graph ID | Intent | Value | Disposition | Flags |
 | --- | --- | --- | --- | --- |
 {{next_work.rows}}
 

package/skills/dashboard/templates/dashboard-project.md

@@ -4,13 +4,13 @@
 
 **Active**
 
-| Id | What | Stage | Worker | Activity |
+| Graph ID | Intent | Stage | Worker | Activity |
 | --- | --- | --- | --- | --- |
 {{active.rows}}
 
 **Most-valuable next work**
 
-| Id | What | Value | Disposition | Flags |
+| Graph ID | Intent | Value | Disposition | Flags |
 | --- | --- | --- | --- | --- |
 {{next_work.rows}}
 

package/skills/doctor/SKILL.md

@@ -78,10 +78,15 @@ project alone.
 Runs the install-wide surface: agent registration, core files (including config-honoring
 drift), manifest sync is core-only and not part of this run, deprecation checks, config-ask
 checks, install-integrity checks, skill-lint (advisory), QMD reachability (unscoped, every
-collection), and the global store's own conventions/done-signals content. **Never carries a
-per-project finding**; that is `--store <slug>`'s job (see above). This is what
-`/plastic-doctor` invokes, and it also runs automatically after every `plastic-update`
-(informational, does not block or revert the update).
+collection), the global store's own conventions/done-signals content, and the `display`
+category (intent 331e): `display_hook_registered` (also runs at `--core`), `display_hook_paints`
+(replays the shipped display fixture through the installed MessageDisplay hook and expects a
+painted screen back, a pass when a known defeater like `NO_COLOR` is active, never a fail),
+`display_not_defeated` (warns per active defeater and always names the undetectable verbose
+transcript view), and `display_surfaces_documented` (the harness-adapters doc still names every
+surface class). **Never carries a per-project finding**; that is `--store <slug>`'s job (see
+above). This is what `/plastic-doctor` invokes, and it also runs automatically after every
+`plastic-update` (informational, does not block or revert the update).
 
 ## When to Use
 
@@ -167,6 +172,7 @@ Use the `fix_hint` value to determine the correct action:
 | "Remove each listed .tmp/<session>/ directory after confirming that session is gone" | For each listed directory, confirm no live session uses it (a live session rewrites its heartbeat on every prompt and edit), then remove that directory by hand; never remove an unlisted one |
 | "For a day directory missing its <day>.md, run `file-session-intent --day <day> ...`" | Run `ruby ~/.plastic/scripts/file-session-intent --day <day> --carry-to <today> --store <store>` for the named day; rename or remove an entry that is not a `YYYYMMDD` day directory |
 | "Run scripts/project-links ... PRESERVES ... --drop-unbacked-links" | Run `ruby ~/.plastic/scripts/maintenance-run --tool project-links --intent <id> --apply` for the one flagged id (never run bare `project-links` against a real store outside the rare owner-approved batch exception, D2) |
+| "Re-run the Plastic installer to repair the hook registration ... (plastic-install --repair)" (`display_hook_registered`) | Run `npx -y @zalom/plastic@<channel> install --reinstall --claude` (the `plastic-install` skill's repair mode), then re-run doctor |
 
 For fixes the agent cannot handle automatically, explain what the user needs
 to do manually. The `revisions.md` remedy is curator-applied (a move-and-record

package/skills/intent-continuing/SKILL.md

@@ -45,32 +45,29 @@ specific intent or roadmap named.").
 
 ## Project route: land on the board
 
-Land on the Markdown board through the `plastic-dashboard` skill; rendering belongs there.
-Run the data payload and fill the matching template:
-- project loaded: `ruby ~/.plastic/scripts/dashboard.rb project <slug> --data`
-- otherwise (the global fallback): `ruby ~/.plastic/scripts/dashboard.rb continue --data`
-
-Fill the template from `plastic-dashboard`'s `templates/` and present the filled Markdown in
-your reply, every time: tool-call stdout and hook context are invisible to the user. Read
-`references/board-fill.md` for the fill mechanics and the store-health line when filling the
-board. The board load runs the scoped store check (`doctor --store <scope>`); its result
-arrives in the payload as `store_health` and is shown as one line of data, never a blocker.
-
-Priority order on the board: active intents first, then project context (governing plus
-tactical intents in a registered project), then stale future intents for triage, then fresh
-future intents as next work. A future intent older than `stale_threshold_days` (default 3) is
-surfaced for triage without action: activate, abandon, or leave. Activating moves it to
+Print `ruby ~/.plastic/scripts/dashboard.rb project <slug> --screen` (or `continue --screen`
+for the global fallback) as the first characters of the reply: nothing before it, no fence, or
+the hook cannot paint it (intent 331d/331f). It carries a title, six fields (Active, In
+delivery, Delivered, Roadmap, Sessions, Changed), then the Where-we-are and Where-we-go-next
+tables. The board load runs the scoped store check (`doctor --store <scope>`); its result
+rides in the payload as `store_health` and prints as one line of data, never a blocker.
+
+Priority order on the underlying data: active intents first, then project context (governing
+plus tactical intents in a registered project), then stale future intents for triage, then
+fresh future intents as next work. A future intent older than `stale_threshold_days` (default
+3) is surfaced for triage without action: activate, abandon, or leave. Activating moves it to
 `## Active` in `INDEX.md` and auto-commits. The board's ranked next-work order is computed by
 `dashboard.rb`; cite the rule names only (Effort, Value, Flags, Override, Caps) and read
 `plastic-dashboard`'s `references/classification.md` for their definitions.
 
 When the tier root (the directory holding `INDEX.md`) has a mid-flight roadmap
 (`ruby ~/.plastic/scripts/roadmap-next --roadmaps-dir <root>/roadmaps` reports a `state`
-other than `none`), say so in one line and offer the roadmap route; the board still presents
+other than `none`), say so in one line and offer the roadmap route; the screen still presents
 project state and stops.
 
 Then stop: "here is the state, what next?". Do not start executing work. When the user names
-an intent, take the intent route.
+an intent, take the intent route. Read `references/board-fill.md` only when the reader asks
+for the deeper prose board (`plastic-dashboard`'s Markdown surface still exists for that ask).
 
 ## Intent route: resume one intent from its ledger
 
@@ -111,11 +108,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
@@ -135,10 +136,11 @@ For a live intent's directory:
    `delivering` or `blocked` entry wins, else the newest ledger or `## Log` timestamp.
    `roadmaps/<slug>.savepoint.md` is a derived signal read here, never a status field;
    `INDEX.md` stays the sole status writer.
-2. **Present state:** the roadmap's `## Goal`, the current batch with each entry's mirrored
-   status, the ledger's newest line beside the newest `## Log` line. Read
-   `../plastic-conventions/references/roadmaps.md` for the file format and the status-mirror
-   rule when a roadmap file needs interpreting.
+2. **Print state.** Print `ruby ~/.plastic/scripts/report-screen roadmap <roadmap.md> state` as
+   the first characters of the reply: nothing before it, no fence, or the hook cannot paint it.
+   It carries Goal, Progress, Frontier, Delivering, Next, and Changed, then the entries table -
+   never hand-typed. Read `../plastic-conventions/references/roadmaps.md` for the file format
+   and the status-mirror rule when a roadmap file needs interpreting.
 3. Then continue with the next dispatchable entry in the session's mode: direct work on it,
    or `plastic-auto` when the owner says auto. The coordinator that drives a batch appends
    to `roadmaps/<slug>.savepoint.md` at its dispatch, merge, park, and handoff points with

package/skills/intent-continuing/references/board-fill.md

@@ -41,3 +41,12 @@ The project route's default target is the project board. When no project is load
 case where this route is reached without a registered project in scope), fall back to the
 global board payload (`dashboard.rb continue --data`) rather than failing. This mirrors the
 router's D6 default: a bare "continue" always lands somewhere useful.
+
+## The screen surface (intent 331d)
+
+`dashboard.rb project <slug> --screen` (or `continue --screen`) prints the identical state -
+Active, In delivery, Delivered, Roadmap, Sessions, Changed, then the Where-we-are and
+Where-we-go-next tables - as a screen with its own grammar instead of a filled Markdown
+template. It replaces this fill mechanism once intent 331f wires the project route to print
+it first, the way the intent route already prints the intent screen first today; until then,
+this page's fill rules stay the route's own surface.