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

package/scripts/report-screen

@@ -0,0 +1,157 @@
+#!/usr/bin/env ruby
+# 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.
+#
+# 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]
+#
+# --ansi delegates to ScreenPaint (intent 317a, D1), the parser/re-layouter
+# in the shared TUI core. Selection is by capability, never by harness:
+# NO_COLOR forces plain, a non-TTY stdout stays plain unless
+# PLASTIC_FORCE_COLOR=1 (the test seam), and an unparseable screen falls
+# open to the plain text untouched.
+#
+# Exit codes:
+#   0 - the screen is on stdout
+#   2 - usage error, or the path/store is not what the verb expects (one line
+#       on stderr, stdout empty)
+
+require "yaml"
+require "shellwords"
+require_relative "lib/report_screen"
+require_relative "lib/intent_screen"
+require_relative "lib/screen_paint"
+
+def usage_abort(message)
+  warn "report-screen: #{message}"
+  exit 2
+end
+
+# The one place allowed to shell out (D2/D20): resolves the tag that CONTAINS
+# the intent's merge commit, in the project's own repository, so the version
+# 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)
+  candidates = []
+  candidates << File.expand_path(explicit_repo) if explicit_repo
+  if (m = intent_dir.match(%r{\A(.*)/projects/([^/]+)/store/[^/]+\z}))
+    home, slug = m[1], m[2]
+    projects_yml = File.join(home, "projects.yml")
+    if File.exist?(projects_yml)
+      data = begin
+        YAML.safe_load(File.read(projects_yml))
+      rescue StandardError
+        nil
+      end
+      entry = data.is_a?(Hash) && data["projects"].is_a?(Hash) ? data["projects"][slug] : nil
+      path = entry.is_a?(Hash) ? entry["path"].to_s : ""
+      candidates << File.expand_path(path) unless path.empty?
+    end
+  end
+  candidates << File.expand_path("..", script_dir)
+  candidates.find { |c| File.exist?(File.join(c, ".git")) }
+end
+
+def git_tag_reader(explicit_repo:, script_dir:)
+  lambda do |intent_dir|
+    sha = ReportScreen.merge_sha(intent_dir)
+    return nil unless sha
+    repo = resolve_repo(intent_dir, explicit_repo, script_dir)
+    return nil unless repo
+    tags = `git -C #{repo.shellescape} tag --contains #{sha.shellescape} 2>/dev/null`
+    versions = tags.lines.map(&:strip).reject(&:empty?).filter_map do |tag|
+      v = tag.sub(/\Av/, "")
+      Gem::Version.correct?(v) ? [Gem::Version.new(v), tag] : nil
+    end
+    versions.min_by(&:first)&.last
+  end
+end
+
+args = ARGV.dup
+verb = args.shift
+changed = nil
+ansi = false
+template_path = nil
+repo_flag = nil
+positional = []
+
+while (arg = args.shift)
+  case arg
+  when "--changed"
+    usage_abort("--changed needs a value") if args.empty?
+    changed = args.shift
+  when "--ansi"
+    ansi = true
+  when "--all"
+    positional << "--all"
+  when "--repo"
+    repo_flag = args.shift or usage_abort("--repo needs a path")
+  when "--template"
+    template_path = args.shift or usage_abort("--template 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
+
+all_mode = positional.delete("--all") ? true : false
+target = positional.first
+
+ansi_enabled = ansi && ENV["NO_COLOR"].to_s.empty? &&
+               ($stdout.tty? || ENV["PLASTIC_FORCE_COLOR"] == "1")
+
+def paint(text, ansi_enabled, _renderer_path = nil)
+  return text unless ansi_enabled
+  ScreenPaint.paint(text, color: true) || text
+end
+
+case verb
+when "state"
+  if all_mode
+    usage_abort("usage: report-screen state --all <store_root>") 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"))
+    out = ReportScreen.render_roster(store_root, changed: changed)
+    $stdout.write paint(out, ansi_enabled)
+  else
+    usage_abort("usage: report-screen state <intent_dir> [--changed \"<text>\"]") unless target
+    intent_dir = File.expand_path(target)
+    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-state.md", __dir__)
+    usage_abort("template not found at #{template_path}") unless File.exist?(template_path)
+    out = ReportScreen.render_state(intent_dir: intent_dir, store_root: store_root, changed: changed,
+                                     template: File.read(template_path))
+    $stdout.write paint(out, ansi_enabled)
+  end
+when "delivered"
+  usage_abort("usage: report-screen delivered <intent_dir>") unless target
+  intent_dir = File.expand_path(target)
+  usage_abort("#{intent_dir} is not an intent directory") unless IntentScreen.intent_dir?(intent_dir)
+  out = ReportScreen.render_delivered(intent_dir: intent_dir,
+                                      tag_reader: git_tag_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
+  intent_dir = File.expand_path(target)
+  usage_abort("#{intent_dir} is not an intent directory") unless IntentScreen.intent_dir?(intent_dir)
+  out = ReportScreen.render_delay(intent_dir: intent_dir)
+  $stdout.write paint(out, ansi_enabled)
+else
+  usage_abort("unknown verb #{verb.inspect} (use state|delivered|delay)")
+end
+
+exit 0

package/scripts/rollback.rb

@@ -118,6 +118,12 @@ class Rollback < InstallerCore
           remove_claude_hooks(path)
           stripped << path
         end
+        # The compact-instructions block (intent 312), for the same reason: no older
+        # package knows the section exists, so nothing there would ever replace or
+        # remove it. The Codex AGENTS.md section needs no equivalent: every older
+        # package knows that one and rewrites it on the downgrade install.
+        claude_md = strip_claude_compact_section(File.join(agent[:dir], "CLAUDE.md"))
+        stripped << claude_md if claude_md
       when "codex"
         path = agent[:home_dir] && File.join(agent[:home_dir], "hooks.json")
         if path && File.exist?(path)

package/scripts/savepoint-note

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+# 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.
+#
+# Usage:
+#   savepoint-note <intent_dir> --kind Review|Commit --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
+# primitive's split(/\s{2,}/) on the prefix alone and silently drop a later
+# line. A newline in --text is refused outright (exit 2, ledger unchanged)
+# rather than silently splitting one entry into two malformed ledger lines.
+#
+# Exit codes:
+#   0 - the line was appended (or was already recorded; both are success)
+#   2 - usage error, bad --kind, missing --text, a newline in --text, or the
+#       path is not an intent directory (one line on stderr, ledger unchanged)
+
+require_relative "lib/savepoint"
+
+def usage_abort(message)
+  warn "savepoint-note: #{message}"
+  exit 2
+end
+
+args = ARGV.dup
+kind = nil
+text = nil
+positional = []
+while (arg = args.shift)
+  case arg
+  when "--kind"
+    kind = args.shift
+  when "--text"
+    text = args.shift
+  else
+    usage_abort("unknown flag #{arg.inspect}") if arg.start_with?("--")
+    positional << arg
+  end
+end
+
+usage_abort("usage: savepoint-note <intent_dir> --kind Review|Commit --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
+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")
+
+normalized = text.gsub(/ {2,}/, " ").strip
+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)
+end
+
+exit 0

package/scripts/spawn-preamble

@@ -24,6 +24,7 @@
 
 require_relative "lib/savepoint"
 require_relative "lib/worktree"
+require_relative "lib/intent_screen"
 
 # Verbatim honoring instruction. Kept as one constant so the contract doc and the
 # test assert against the exact same string.
@@ -115,11 +116,17 @@ STAGE_LABELS = {
   "exec" => "Exec", "done" => "Done"
 }.freeze
 
+# Intent 317, D6: a dispatched agent's "Current stage:" line must name the last
+# LIFECYCLE line (What/Why/How/Exec/Done), never a trailing Lock/Review/Commit
+# line - the bug spawn-preamble shared with IntentScreen.savepoint_fields
+# before this guard (plan review finding B1).
 def current_stage(intent_dir)
   ledger = File.join(intent_dir, Savepoint::SAVEPOINT_FILE)
   if File.exist?(ledger)
-    last = File.read(ledger).each_line.map(&:strip).reject(&:empty?).last
-    return last if last
+    lines = File.read(ledger).each_line.map(&:strip).reject(&:empty?)
+    lifecycle = lines.select { |l| IntentScreen.lifecycle_line?(l) }
+    return lifecycle.last if lifecycle.any?
+    return lines.last if lines.any?
   end
   STAGE_LABELS.fetch(Savepoint.derive_stage(intent_dir), Savepoint.derive_stage(intent_dir))
 end

package/scripts/write-handoff

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# write-handoff (intent 311): render and write one session's hand-off into
+# the day directory (.sessions/<day>/handoff--<session>.md). Derived from the
+# day ledger, so it can be regenerated at any time. Prints the path.
+#
+# Usage:
+#   write-handoff --trigger tick|precompact|close [--store <dir>] [--day <YYYYMMDD>]
+#                 [--session <id>] [--templates <dir>]
+#
+# Defaults match append-ledger: the store is $PLASTIC_HOME/store, the day is
+# today (local wall clock), the session is $CLAUDE_CODE_SESSION_ID, and the
+# templates dir is the one shipped next to this script.
+#
+# Exit codes: 0 done; 2 usage error.
+
+require_relative "lib/session_ledger"
+require_relative "lib/handoff"
+
+def usage_abort(message)
+  warn "write-handoff: #{message}"
+  exit 2
+end
+
+def expand(path)
+  File.expand_path(path.to_s.sub(/\A~/, Dir.home))
+end
+
+def parse_args(argv)
+  opts = {}
+  i = 0
+  while i < argv.length
+    flag = argv[i]
+    usage_abort("unknown argument #{flag.inspect}") unless flag.start_with?("--")
+    usage_abort("#{flag} requires a value") if i + 1 >= argv.length
+    key = flag.delete_prefix("--").to_sym
+    usage_abort("unknown flag #{flag.inspect}") unless %i[store day session trigger templates].include?(key)
+    opts[key] = argv[i + 1]
+    i += 2
+  end
+  opts
+end
+
+opts = parse_args(ARGV)
+usage_abort("--trigger is required (#{Handoff::TRIGGERS.join(', ')})") unless opts[:trigger]
+usage_abort("--trigger must be one of #{Handoff::TRIGGERS.join(', ')}") unless Handoff::TRIGGERS.include?(opts[:trigger])
+
+plastic_home = expand(ENV.fetch("PLASTIC_HOME", "~/.plastic"))
+store = opts[:store] ? expand(opts[:store]) : File.join(plastic_home, "store")
+templates = opts[:templates] ? expand(opts[:templates]) : File.expand_path("../templates", __dir__)
+usage_abort("templates dir not found: #{templates}") unless Dir.exist?(templates)
+
+day = opts[:day] || SessionLedger.day_id
+usage_abort("--day must be eight digits parsing as a real date, got #{day.inspect}") unless SessionLedger.valid_day_id?(day)
+session = SessionLedger.short_session_id(opts[:session], ENV["CLAUDE_CODE_SESSION_ID"])
+
+puts Handoff.write(store: store, day: day, session: session, trigger: opts[:trigger], templates: templates)
+exit 0

package/skills/auto/SKILL.md

@@ -67,8 +67,9 @@ Replace `<STORE>` (`~/.plastic/projects/<slug>/store` or `~/.plastic/store`) and
 nonblank `CLAUDE_CODE_SESSION_ID` as Claude, otherwise passes no identity and the verb keys the
 lock by a derived session key. Never guess identity from an absent runtime variable; an
 unknown harness or thread stays unknown. Exit 1 means the lock is held, stale, excluded, or
-corrupt; the message names the `plastic-doctor` verb that resolves it. Do not proceed as the
-owner after an exit 1.
+corrupt - or `inline_refused`: a conversation session may not arm an intent at all (owner rule
+2026-08-31); dispatch the delivery team instead. `--allow-inline` exists only for an explicit
+owner override. Do not proceed as the owner after an exit 1.
 
 Read `../plastic-conventions/references/locks-and-worktrees.md` for what the lock and the
 worktree mean and the station table behind them. Code edits happen only inside the worktree.
@@ -200,9 +201,11 @@ 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. Notify the user (the one mid-flight briefing, per `references/human-report-contract.md`):
-   State, the plan shape and what it builds; Risk, the riskiest row of the matrix; Call,
-   proceeding to build. In auto mode this briefing informs; it does not wait.
+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.
 
 Then Exec.
 
@@ -252,7 +255,8 @@ every choice is non-destructive and the team has full autonomy.
 Read `../plastic-conventions/references/completion-and-done.md` for what "intent done" means.
 
 1. Verify every checklist item is checked and the suite is green once on the branch.
-2. Write `outcome.md` from `~/.plastic/templates/outcome.md` with `disposition: delivered`.
+2. Write `outcome.md` from `~/.plastic/templates/outcome.md` with `disposition: delivered`,
+   `## Delivered` as the labeled table whose row labels match the action-file headings (317a).
 3. Release, if configured: match the working directory against `~/.plastic/projects.yml`, read
    `project.yml`'s `release` block, and act on `on_complete` (`commit`, `commit_and_push`,
    `manual`), `verify` (green proceeds; red follows `on_red`: `fix_and_retry` up to twice,
@@ -272,6 +276,9 @@ Read `../plastic-conventions/references/completion-and-done.md` for what "intent
    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.
 
 ## Error Handling
 
@@ -284,8 +291,8 @@ leaves the project broken.
 
 - Read `references/agent-architecture.md` for the team model, the risk list, the headless note,
   and the solo fallback when dispatching or when a harness has no agent dispatch.
-- Read `references/human-report-contract.md` for the State/Risk/Call briefing before sending the
-  How briefing.
+- Read `references/human-report-contract.md` for the three report screens and the five
+  triggers before printing the How or Completion screen above.
 - Read `references/agent-report-contract.md` for the completion report format when reading a
   dispatched agent's return or synthesizing one.
 - Read `references/end-tail.md` for what `Arm.disarm` does at the End tail and why the reindex

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

@@ -1,72 +1,78 @@
-# Human Report Contract (per-stage EM-to-CTO briefing)
-
-This doc defines how the orchestrator briefs the human at each of the five stage boundaries
-(What, Why, How, Exec, Done) in auto mode; for small work only the How boundary fires (see
-`## Depth for small work`). It is the outward, human-facing counterpart to the
-internal report contract in `references/agent-report-contract.md`. Voice: an engineering
-manager briefing a CTO. Lead with impact, name the risk, leave the decision.
-
-## The skeleton
-
-One fixed 3-line shape, reused at every stage:
-
-1. **State**: what happened and what it means, impact first, one line.
-2. **Risk**: the one thing that could bite, or "nothing flagged."
-3. **Call**: the decision left to you, or the go-ahead I am taking.
-
-This is a shape, not a rigid template. Keep the order (State, then Risk, then Call) and keep it
-short. The words can flex to fit the stage.
-
-## Per-stage content
-
-- **What**: State = the work I picked up and why it matters now. Risk = scope uncertainty.
-  Call = confirm this is worth doing, or I proceed.
-- **Why**: State = the approach I chose, one line. Risk = the main trade-off. Call = the one
-  decision I need (approve, or pick an option).
-- **How**: State = the plan shape (task count and what it builds). Risk = the riskiest task or
-  dependency. Call = approve the plan to build.
-- **Exec**: State = what got built and the test result. Risk = residual failures or deviations.
-  Call = go to review, or done.
-- **Done**: State = the delivered impact. Risk = residual risk. Call = the decision left to you
-  (merge, release, accept).
+# Human Report Contract (the three 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
+written by eye:
+
+- **`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.
+- **`report-screen state --all <store_root>`** - the roster across every in-delivery intent,
+  most recently changed first, then one collapsed block (Stage, Next, Changed, first three
+  open steps) per intent.
+- **`report-screen delivered <intent_dir>`** - the post-delivery report, printed once at close:
+  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.
+
+## The five triggers for `state`
+
+Print `state` (one intent, or `--all` for the roster) on any of these; a checklist tick alone,
+an executor's intermediate commit, or an agent going idle is NOT one of them:
+
+| Trigger | Scope |
+|---|---|
+| A savepoint line lands (a stage boundary: Why, How, Exec started, outcome written, Done) | that intent |
+| A review verdict returns (plan review or post-execution review), naming what it changed | that intent |
+| A blocker or needs-input is logged | that intent |
+| A merge or a release lands | that intent |
+| The owner asks ("where are we", "state of X", "continue X") | all in delivery, or the one named |
+
+`delivered` prints exactly once, at Completion. `delay` prints only when the owner asks why a
+delivery took long.
+
+Every verb prints the same plain Markdown on every harness (owner ruling 2026-08-31); where a
+harness can paint it (Claude Code, through 316a's message-display hook), it substitutes a
+painted rendering of that same output, never a different one, and no skill or script branches
+on harness name to decide.
 
 ## Depth for small work
 
-For small work in auto mode the mid-flight briefings collapse to one. Only the How briefing fires, and
-it folds in what the What and Why briefings would have said: the work picked up and the approach
-chosen go into its State line. The Exec briefing folds into the final owner report at End. Larger
-work sends all four. The shape does not change: still State, then Risk, then Call, and the per-stage
-content above still says what each line covers. This is a depth cut, not a new report. A delivery
-still ends with `outcome.md` plus one owner report.
+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
+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.
 
 ## One report per audience
 
 A delivery produces exactly two artifacts: `outcome.md` (authored by `plastic-intent-ending`)
-and one EM-to-CTO owner report at the End stage. No stage or skill restates a delivery
-already written to `outcome.md`; point at it instead. Skills do not open with a banner that
-names the skill or restates the intent id and name the owner just typed. Announce only what
-the reader cannot already know: an error, a result, a choice with its reason, or a handoff.
+and one `delivered` screen at the End stage. No stage or skill restates a delivery already
+written to `outcome.md`; point at it instead. Skills do not open with a banner that names the
+skill or restates the intent id and name the owner just typed. Announce only what the reader
+cannot already know: an error, a result, a choice with its reason, or a handoff.
 
 ## Boundary vs intent 74
 
 Intent 74's report contract (`references/agent-report-contract.md`) is the INTERNAL,
 machine-checked handoff from a dispatched specialist back to the orchestrator: a structured
-envelope plus a per-role payload. This contract is the OUTWARD human briefing, orchestrator to
-user, in prose. Different direction, different audience, different form. The orchestrator
-CONSUMES the intent 74 report to WRITE the human briefing defined here. The two never merge.
+envelope plus a per-role payload. This contract is the OUTWARD screen shown to the owner.
+Different direction, different audience, different form. The orchestrator reads the intent 74
+report and reflects it into the record (savepoint, outcome.md) that `report-screen` then
+renders. The two never merge.
 
 ## Brevity: point, don't repeat
 
-Surface rules are owned by the `writing-style` skill. This contract does not restate them, in full
-or in summary. It defines the report's shape only: what to say, in what order, and when to stop.
-Apply the `writing-style` skill for the wording.
+Surface rules are owned by the `writing-style` skill. This contract does not restate them. Its
+job is naming which screen prints when, not the wording inside it - `report-screen` derives
+every cell from the record (D14), so there is no prose left to style here.
 
 ## Emission: guided vs auto
 
-In guided mode, the briefing lands at each stage boundary and the human acts on the Call line
-before the next stage starts.
+In guided mode, `state` prints at each stage boundary and the human decides before the next
+stage starts.
 
-In auto mode, for larger work the orchestrator still emits the briefing at each boundary, as a
-running EM-to-CTO account. For small work only the How briefing fires; see `## Depth for small work` above for what it
-folds in. The Call line becomes the go-ahead the orchestrator takes itself and moves on, except at
-the existing hard stops (destructive action without a safe alternative, project-path confirm).
+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).

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

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

package/skills/intent-continuing/SKILL.md

@@ -5,7 +5,7 @@ description: >-
   where we left off", "where was I", "what should I work on", names a specific intent to
   resume (by id or description, or `--intent {id}`), or names a roadmap or delivery batch to
   resume (`--roadmap {slug}`, "where is the roadmap", "where did that batch land"). Presents
-  state and resumes at the last delivered station; it never asks auto or guided, never boots
+  state and resumes at the last delivered stage; it never asks auto or guided, never boots
   (the SessionStart hook owns boot), and never drives work autonomously (plastic-auto does).
   Absorbs the former continuing, project-continuing, and roadmap-continuing skills and the
   read half of the former intent-starting skill (intent 304).
@@ -79,40 +79,49 @@ QMD-first when the intent is named by description: run
 authoritative intent file. The command is a no-op when QMD is absent; fall back to
 `INDEX.md`.
 
-If the intent is terminal (`## Completed` or `## Abandoned` in `INDEX.md`): report only.
-Summarize its `outcome.md` and ask what is next; never reopen it.
+If the intent is terminal (`## Completed` or `## Abandoned` in `INDEX.md`): print the
+intent screen (Status shows the terminal section, Next is empty), summarize its
+`outcome.md`, and ask what is next; never reopen it.
 
 For a live intent's directory:
 
 1. **Read `savepoint.md` first.** It is a deterministic, append-only ledger, one line per
-   event, newest at the bottom: `{utc-iso8601}  {Stage}  {milestone}`. Classify the station
+   event, newest at the bottom: `{utc-iso8601}  {Stage}  {milestone}`. Classify the stage
    from the last line alone (the table in `references/boarding-matrix.md`, read when
    classifying), then verify only that line's artifact is real (sentinel-aware:
    `Savepoint.stage_file_present?`). Do not re-probe every lifecycle file.
-2. **Drift.** When the last line disagrees with the files on disk, rebuild the ledger from
+2. **Stale ledger.** When the last line disagrees with the files on disk, rebuild the ledger from
    disk and note the correction. A rebuilt ledger is the file-landing skeleton, which still
-   pins the station:
+   pins the stage:
    ```bash
    ruby -r ~/.plastic/scripts/lib/savepoint -e 'Savepoint.rebuild_savepoint("<intent_dir>")'
    ```
-3. **Read the hand-off.** When `resources/handoff--*.md` exists, its newest file is the prior
-   session's own account of where things stand; read it after the ledger, never instead of it.
+3. **Read the hand-off.** The newest `~/.plastic/store/.sessions/<day>/handoff--*.md` (today,
+   else the newest prior day) is the prior session's own account of where things stand; read
+   it after the ledger, never instead of it.
 4. **Derive the next step:** the first unchecked item in `checklist.md` when it exists, else
-   the next thing the station needs (see the matrix). The newest `## Insights` entry supplies
+   the next thing the stage needs (see the matrix). The newest `## Insights` entry supplies
    the human-readable context; an entry marked `(autonomous)` means an auto team was
    delivering it, so say so and offer to hand back to `plastic-auto`.
-5. **Announce, then continue at that station:**
-   ```
-   Resuming intent [ID] - [name]
-   Store: [global | project:<slug>]
-   Station: [from the ledger's last line]
-   Next step: [first unchecked checklist item | what the station needs]
-   Context: [newest ## Insights entry | hand-off summary]
-   Drift: [none | ledger rebuilt from disk]
-   ```
-   Then continue the work in the session's current mode. In auto mode the running team
-   already holds the delivery lock; if a lock is held by a session that is gone, the
-   `plastic-doctor` skill's lock section repairs or reclaims it.
+5. **Print the report screen as the first thing in the reply, then continue at that stage.**
+   The screen must open the message with nothing before it. On Claude Code, a fail-open
+   `MessageDisplay` hook recognizes a reply that opens this way and substitutes a styled ANSI
+   rendering for it there; the transcript and every other harness keep exactly this plain
+   form. For "where are we" on one named intent, run
+   `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
+   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
+   session's current mode. In auto mode the running team already holds the delivery lock; if a
+   lock is held by a session that is gone, the `plastic-doctor` skill's lock section repairs or
+   reclaims it.
 
 ## Roadmap route: resume the mid-flight roadmap
 
@@ -140,6 +149,6 @@ For a live intent's directory:
 | Trigger | Read |
 |---|---|
 | Filling the board on the project route | `references/board-fill.md` |
-| Classifying the station from the ledger's last line | `references/boarding-matrix.md` |
+| Classifying the stage from the ledger's last line | `references/boarding-matrix.md` |
 | Explaining why one roadmap ranked above another | `references/liveness-ranking.md` |
 | Saving or restoring context across a long session, or debugging a resume | `references/context-management.md` |