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

package/scripts/lib/screen_paint.rb

@@ -0,0 +1,276 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require_relative "intent_screen_ansi"
+
+# ScreenPaint (intent 317a, D1) - the paint seam 317's Needs-you named. Parses
+# the plain Markdown screens our own renderers emit (intent, state, roster,
+# delivered, delay) and re-lays them out in the shipped intent-screen ANSI
+# vocabulary. A parser and RE-LAYOUTER, not a colorizer (A5): the plain
+# screens are pipe tables whose scaffolding rows only disappear under a
+# Markdown renderer, so the painter drops them and rebuilds the layout;
+# content-survival is the contract - every value and note survives, nothing
+# is invented, and text it does not recognize returns nil so every caller
+# fails open to plain.
+#
+# Harness-agnostic core: no harness assumption lives here. No ENV, no TTY. Color, width, and
+# markdown_safe are caller arguments, exactly like IntentScreenAnsi before it
+# (316a1); the 318 ceiling holds - the palette is IntentScreenAnsi's, no new
+# colors, no box borders.
+module ScreenPaint
+  A = IntentScreenAnsi
+
+  # A screen's first line: "## ▶ id · name", "## ✔ id · name · delivered",
+  # "▶ In delivery · ...", "✔ id · name · delivered in ...".
+  OPENER_RE = /\A(?:## )?[▶✔] .+ · /.freeze
+
+  FIELD_LINE_RE = /\A(Stage|Next|Changed|Lead|Progress)(\s{2,})(.*)\z/.freeze
+  STEP_LINE_RE = /\A(S\d+)\s+\[ (open|done) \]\s+(.*)\z/.freeze
+  TIMELINE_RE = /\A(\d\d:\d\d)\s{2}(\S+)\s{2}(.*)\z/.freeze
+  COUNT_LINE_RE = /\A\d+ open( · .*)?\z/.freeze
+  BOLD_LEAD_RE = /\A\*\*([^*]+)\*\*(.*)\z/.freeze
+
+  # Intent 317a1 (D3, D4, D5): the data-table palette. Kind and note columns
+  # are chosen by the table's own header, never by position; a cell whose
+  # text is exactly "not recorded" greys wherever it appears.
+  EVIDENCE_PROOF_KINDS = %w[suite red ship doctor deposits verdict].freeze
+  EVIDENCE_DEVIATION_KINDS = %w[deviates].freeze
+  NOTE_HEADERS = %w[Source Why].freeze
+  NOT_RECORDED = "not recorded"
+
+  module_function
+
+  # The classifier both paint and region_end share. `idx`/`opener_idx` give
+  # the positional rule its footing: the line right after a title is the meta
+  # line (delivered/delay print one), recognizable by its " · " separators.
+  def classify(line, idx: nil, opener_idx: nil)
+    text = line.chomp
+    stripped = text.strip
+    return :blank if stripped.empty?
+    return :opener if OPENER_RE.match?(stripped) && text == stripped
+    return :table if text.lstrip.start_with?("|")
+    return :bold if BOLD_LEAD_RE.match?(stripped) && text == stripped
+    return :meta if idx && opener_idx && idx == opener_idx + 1 && stripped.include?(" · ")
+    return :indented if text.start_with?("  ")
+    return :field if FIELD_LINE_RE.match?(text)
+    return :step if STEP_LINE_RE.match?(text)
+    return :timeline if TIMELINE_RE.match?(text)
+    return :count if COUNT_LINE_RE.match?(stripped)
+    return :closer if ["None", "not recorded", "No intents in delivery."].include?(stripped)
+    :unknown
+  end
+
+  # Where the screen region ends inside a larger message (B10): walk from the
+  # opener while every line classifies; the first unknown line - ordinary
+  # prose, a prose bullet - is the boundary. Never consumes past the screen.
+  def region_end(lines, start_idx)
+    i = start_idx + 1
+    while i < lines.length
+      kind = classify(lines[i], idx: i, opener_idx: start_idx)
+      break if kind == :unknown
+      # A bare "**Section**" head belongs to the screen only when what follows
+      # is still grammar; "**What this means**" over prose bullets is the
+      # model's own commentary and stays outside, unsplit (B10).
+      if kind == :bold && bare_bold?(lines[i]) && !grammar_follows?(lines, i, start_idx)
+        break
+      end
+      i += 1
+    end
+    # Trailing blanks belong to the message, not the screen.
+    i -= 1 while i > start_idx + 1 && lines[i - 1].strip.empty?
+    i
+  end
+
+  def bare_bold?(line)
+    m = BOLD_LEAD_RE.match(line.strip)
+    m && m[2].to_s.strip.empty?
+  end
+
+  def grammar_follows?(lines, idx, opener_idx)
+    j = idx + 1
+    j += 1 while j < lines.length && lines[j].strip.empty?
+    return false if j >= lines.length
+    kind = classify(lines[j], idx: j, opener_idx: opener_idx)
+    kind != :unknown && kind != :opener
+  end
+
+  # The painter. Returns the ANSI (or plain re-laid, when color: false) text,
+  # or nil when the input does not open with a screen title or carries a line
+  # outside the grammar - the caller's cue to print the original untouched.
+  def paint(text, color: true, width: A::DEFAULT_WIDTH, markdown_safe: false)
+    lines = text.to_s.lines
+    first_idx = lines.index { |l| !l.strip.empty? }
+    return nil if first_idx.nil?
+    return nil unless classify(lines[first_idx]) == :opener
+
+    out = +""
+    table = []
+    ok = true
+    indent_run = 0
+
+    flush = lambda do
+      next if table.empty?
+      out << paint_table(table, color: color, width: width, markdown_safe: markdown_safe)
+      table.clear
+    end
+
+    lines.each_with_index do |line, idx|
+      kind = classify(line, idx: idx, opener_idx: first_idx)
+      # Intent 317a1 (O6, D8): the run counter tracks consecutive :indented
+      # lines so only the SECOND and later lines under a heading like
+      # "**Asked**" grey as a note; a :table line (which `next`s below) must
+      # reset it too, so a later unrelated indented block starts fresh.
+      indent_run = kind == :indented ? indent_run + 1 : 0
+      if kind == :table
+        table << line.strip
+        next
+      end
+      flush.call
+      case kind
+      when :opener
+        t = clean(line.strip.sub(/\A## /, ""), markdown_safe)
+        out << A.fit(t, width) { |s| A.styled(s, color, A::BOLD, A::NEARWHITE) } << "\n"
+      when :meta
+        out << A.fit(clean(line.strip, markdown_safe), width) { |s| A.styled(s, color, A::MIDGREY) } << "\n"
+      when :bold
+        m = BOLD_LEAD_RE.match(line.strip)
+        head = A.styled(clean(m[1], markdown_safe), color, A::BOLD, A::NEARWHITE)
+        out << head << clean(m[2], markdown_safe) << "\n"
+      when :indented
+        text = A.fit_plain(clean(line.chomp, markdown_safe), width)
+        out << (indent_run > 1 ? A.styled(text, color, A::MIDGREY) : text) << "\n"
+      when :field
+        m = FIELD_LINE_RE.match(line.chomp)
+        out << A.styled(m[1].ljust(8), color, A::BOLD) << "  " << clean(m[3], markdown_safe) << "\n"
+      when :step
+        m = STEP_LINE_RE.match(line.chomp)
+        badge = A.status_cell(m[2] == "done", color)
+        out << "#{m[1].ljust(4)} [#{badge}]  #{A.fit_plain(clean(m[3], markdown_safe), width - 12)}\n"
+      when :timeline
+        # Intent 317a1 (O5, D6, D7): the time carries no escape at all; the
+        # kind label carries the color - amber for the review turning point,
+        # teal for a landed commit, mid-grey (no bold) otherwise.
+        m = TIMELINE_RE.match(line.chomp)
+        codes = case m[2]
+                when "Review" then [A::BOLD, A::AMBER]
+                when "Commit" then [A::BOLD, A::TEAL]
+                else [A::MIDGREY]
+                end
+        out << m[1] << "  " << A.styled(m[2].ljust(6), color, *codes) << "  " << clean(m[3], markdown_safe) << "\n"
+      when :count
+        out << A.fit(line.strip, width) { |s| A.styled(s, color, A::MIDGREY) } << "\n"
+      when :closer
+        out << A.styled(line.strip, color, A::MIDGREY) << "\n"
+      when :blank
+        out << "\n"
+      else
+        ok = false
+        break
+      end
+    end
+    flush.call
+    return nil unless ok
+
+    paint_bars(out.gsub(/\n{3,}/, "\n\n"), color)
+  end
+
+  # --- tables -----------------------------------------------------------------
+
+  SEPARATOR_RE = /\A\|[\s:|-]+\|?\z/.freeze
+
+  def cells_of(row)
+    row.split("|", -1).map(&:strip)[1..-2].to_a
+  end
+
+  def field_table?(rows)
+    rows.first&.gsub(/[\s|]/, "") == "" || cells_of(rows.first).first.to_s.start_with?("**")
+  end
+
+  # A field table ("| | | |" scaffold, "| **Key** | value | note |" rows)
+  # re-lays as the intent screen's three-column field block: bold key,
+  # value, and a mid-grey note that shares the line when it fits, dropping
+  # to its own line only as a fallback (D9-D11). A data table re-lays as
+  # padded columns with a bold header, done/open cells colored, no pipes
+  # anywhere.
+  def paint_table(rows, color:, width:, markdown_safe:)
+    rows = rows.reject { |r| SEPARATOR_RE.match?(r) || r.gsub(/[\s|]/, "").empty? }
+    return "" if rows.empty?
+
+    if cells_of(rows.first).first.to_s.start_with?("**")
+      return paint_field_table(rows, color: color, width: width, markdown_safe: markdown_safe)
+    end
+
+    paint_data_table(rows, color: color, markdown_safe: markdown_safe)
+  end
+
+  # Intent 317a1 (O3, D9-D11, D14, D15): the same three-column geometry as
+  # IntentScreenAnsi.render's field-row loop, on the SAME implementation
+  # (D12) - `IntentScreenAnsi.field_table_lines` - so the two renderers
+  # cannot drift apart. Notes arrive as plain text here, so `visible_width`
+  # equals `length`, but the shared helper is used anyway so both renderers
+  # read identically.
+  def paint_field_table(rows, color:, width:, markdown_safe:)
+    key_w = rows.map { |r| cells_of(r).first.to_s.gsub("*", "").length }.max
+    field_rows = rows.map do |row|
+      key, value, note = cells_of(row)
+      key = key.to_s.gsub("*", "")
+      [key, clean(value.to_s, markdown_safe), clean(note.to_s, markdown_safe)]
+    end
+    A.field_table_lines(field_rows, width: width, color: color, key_width: key_w)
+  end
+
+  # Intent 317a1 (O4, D3-D5): a data table's kind and note columns are chosen
+  # by the header, never by position; a cell whose text is exactly "not
+  # recorded" greys wherever it appears. `widths[ci] || 0` (rather than a
+  # bare `widths[ci]`) is the ragged-row guard: `ReportScreen.escape` writes
+  # `\|` while `cells_of` still splits on every `|`, so a row can carry more
+  # cells than its header without either side ever raising.
+  def paint_data_table(rows, color:, markdown_safe:)
+    grid = rows.map { |r| cells_of(r).map { |c| clean(c, markdown_safe) } }
+    widths = grid.first.each_index.map { |i| grid.map { |r| r[i].to_s.length }.max }
+    kind_col = grid.first.first == "Kind" ? 0 : nil
+    note_col = grid.first.index { |h| NOTE_HEADERS.include?(h) }
+
+    out = +""
+    grid.each_with_index do |cols, ri|
+      last_ci = cols.length - 1
+      cells = cols.each_with_index.map do |cell, ci|
+        padded = ci == last_ci ? cell.to_s : cell.to_s.ljust(widths[ci] || 0)
+        # An empty cell never gets styled (317a1 post-exec review, finding
+        # 1): `A.styled("", ...)` still emits a color-open/RESET pair around
+        # nothing visible, and that hides the join separator's own trailing
+        # spaces from `.rstrip` below, on the very line the reader sees.
+        next padded if cell.to_s.empty?
+        if ri.zero?
+          A.styled(padded, color, A::BOLD)
+        elsif ci == kind_col && EVIDENCE_PROOF_KINDS.include?(cell)
+          A.styled(padded, color, A::TEAL, A::BOLD)
+        elsif ci == kind_col && EVIDENCE_DEVIATION_KINDS.include?(cell)
+          A.styled(padded, color, A::AMBER, A::BOLD)
+        elsif ci == note_col
+          A.styled(padded, color, A::MIDGREY)
+        elsif cell == "done"
+          A.styled(padded, color, A::TEAL)
+        elsif cell == "open"
+          A.styled(padded, color, A::AMBER)
+        elsif cell == NOT_RECORDED
+          A.styled(padded, color, A::MIDGREY)
+        else
+          padded
+        end
+      end
+      out << "  " << cells.join("  ").rstrip << "\n"
+    end
+    out
+  end
+
+  def paint_bars(text, color)
+    return text unless color
+    text.gsub(/█+/) { |run| "#{A::TEAL}#{run}#{A::RESET}" }
+        .gsub(/░+/) { |run| "#{A::MIDGREY}#{run}#{A::RESET}" }
+  end
+
+  def clean(text, markdown_safe)
+    markdown_safe ? A.clean(text) : text
+  end
+end

package/scripts/lib/session_close.rb

@@ -9,12 +9,22 @@
 
 require "fileutils"
 require_relative "session_ledger"
+require_relative "handoff"
 
 module SessionClose
   module_function
 
   NOOP_REASONS = %w[clear resume].freeze
 
+  # The default hand-off writer (intent 311, spec D6): renders this session's
+  # share of the pointer day into handoff--<session>.md before the tmp dir
+  # goes. The hook script builds it with the shipped templates dir.
+  def default_handoff(templates)
+    lambda do |store, day, session|
+      Handoff.write(store: store, day: day, session: session, trigger: "close", templates: templates)
+    end
+  end
+
   # The default spawner starts the day filer detached so a slow filing never
   # blocks the harness shutdown (Codex kills a SessionEnd hook after 3 s).
   def default_spawner(script)
@@ -26,8 +36,8 @@ module SessionClose
   end
 
   # Returns a small report hash; never raises.
-  def run(payload:, store:, today:, spawner:, now: Time.now)
-    report = { reason: nil, dropped: 0, removed_tmp: false, spawned: nil }
+  def run(payload:, store:, today:, spawner:, handoff: nil, now: Time.now)
+    report = { reason: nil, dropped: 0, removed_tmp: false, spawned: nil, handoff: false }
     reason = payload.is_a?(Hash) ? payload["reason"].to_s : ""
     report[:reason] = reason
     return report if NOOP_REASONS.include?(reason)
@@ -49,6 +59,16 @@ module SessionClose
       count
     end || 0
 
+    # The hand-off (intent 311, spec D6) is written after the drop, so it
+    # reflects it, and before the tmp dir goes, since the pointer lives there.
+    # An intent pointer falls back to today, the same as the drop above.
+    if handoff
+      report[:handoff] = safely do
+        handoff.call(store, pointer_day, session)
+        true
+      end || false
+    end
+
     report[:removed_tmp] = safely do
       dir = SessionLedger.session_tmp_dir(store, session)
       FileUtils.rm_rf(dir) if Dir.exist?(dir)

package/scripts/lib/session_git.rb

@@ -207,11 +207,37 @@ module SessionGit
 
   # --- commit message ------------------------------------------------------------
 
-  # The first line of `summary`, truncated to MAX_SUBJECT_LENGTH characters,
-  # with no trailer (spec D5).
+  # The first line of `summary`, cut at the last word boundary at or before
+  # MAX_SUBJECT_LENGTH characters, falling back to the hard slice when no
+  # boundary exists at or before the limit (spec D6, amends spec 300 D5's
+  # unconditional `first_line[0, MAX_SUBJECT_LENGTH]`, which cut mid-word).
+  # A subject at or under the limit is returned unchanged. Post-execution
+  # review item 7: when the character immediately after the 72-char prefix
+  # is ITSELF a space, the prefix already ends exactly on a word boundary and
+  # needs no trimming at all -- checked before consulting `rindex`, because
+  # an earlier internal space inside the 72-char prefix would otherwise make
+  # `rindex` walk back past a whole trailing word that fit perfectly.
   def subject_for(summary)
     first_line = summary.to_s.split(/\r?\n/, 2).first.to_s.strip
-    first_line[0, MAX_SUBJECT_LENGTH]
+    return first_line if first_line.length <= MAX_SUBJECT_LENGTH
+
+    cut = first_line[0, MAX_SUBJECT_LENGTH]
+    return cut if first_line[MAX_SUBJECT_LENGTH] == " "
+
+    boundary = cut.rindex(" ")
+    boundary ? cut[0, boundary] : cut
+  end
+
+  # The commit body for `summary`/`subject` (spec D6): the full summary when
+  # `subject` is a cut-down copy of it, nil when the subject already carries
+  # the summary whole (no redundant body on a short, single-line summary).
+  # Post-execution review item 4: compares the STRIPPED raw summary, not the
+  # raw summary verbatim -- a summary with only trailing/leading whitespace
+  # around an otherwise-identical subject must not repeat the same sentence
+  # twice as a redundant body.
+  def body_for(summary, subject)
+    raw = summary.to_s
+    raw.strip == subject ? nil : raw
   end
 
   # --- git primitives (all use -C, never cwd) -------------------------------------
@@ -273,9 +299,11 @@ module SessionGit
     parts.each_cons(2).any? { |a, b| a == ".claude" && b == "worktrees" }
   end
 
-  def stage_and_commit(dir, subject, runner:)
+  def stage_and_commit(dir, subject, runner:, body: nil)
     runner.run("-C", dir, "add", "-A")
-    runner.run("-C", dir, "commit", "-m", subject)
+    args = ["-C", dir, "commit", "-m", subject]
+    args += ["-m", body] if body
+    runner.run(*args)
   end
 
   def short_sha(dir, runner:)
@@ -310,14 +338,16 @@ module SessionGit
 
     flow, flow_notes = load_flow(cwd: cwd, repo: repo, plastic_home: plastic_home, runner: runner)
     subject = subject_for(summary)
+    body = body_for(summary, subject)
 
     result =
       if flow["mode"] == "pull_request"
-        commit_pull_request(repo: repo, subject: subject, day: day, session: session,
+        commit_pull_request(repo: repo, subject: subject, body: body, day: day, session: session,
                              store: effective_store, flow: flow, branch_now: branch_now,
                              runner: runner, gh_runner: gh_runner)
       else
-        commit_direct(repo: repo, subject: subject, day: day, flow: flow, branch_now: branch_now, runner: runner)
+        commit_direct(repo: repo, subject: subject, body: body, day: day, flow: flow, branch_now: branch_now,
+                       runner: runner)
       end
 
     return result if flow_notes.empty?
@@ -331,7 +361,7 @@ module SessionGit
 
   # --- direct mode (spec D3) --------------------------------------------------------
 
-  def commit_direct(repo:, subject:, day:, flow:, branch_now:, runner:)
+  def commit_direct(repo:, subject:, day:, flow:, branch_now:, runner:, body: nil)
     return note("nothing to commit") unless dirty?(repo, runner: runner)
     return note("summary is empty after truncation: no commit") if blank?(subject)
 
@@ -351,10 +381,10 @@ module SessionGit
     end
 
     if branch_now == base || branch_now == session_branch
-      commit_on_session_branch(repo: repo, subject: subject, base: base,
+      commit_on_session_branch(repo: repo, subject: subject, base: base, body: body,
                                 session_branch: session_branch, branch_now: branch_now, runner: runner)
     else
-      commit_on_other_branch(repo: repo, subject: subject, branch_now: branch_now, runner: runner)
+      commit_on_other_branch(repo: repo, subject: subject, body: body, branch_now: branch_now, runner: runner)
     end
   end
 
@@ -367,7 +397,7 @@ module SessionGit
   # session branch. `current_branch` is re-read after the switch and used
   # for the commit message instead of trusting the branch this method
   # intended to reach.
-  def commit_on_session_branch(repo:, subject:, base:, session_branch:, branch_now:, runner:)
+  def commit_on_session_branch(repo:, subject:, base:, session_branch:, branch_now:, runner:, body: nil)
     unless branch_exists?(repo, session_branch, runner: runner)
       create = runner.run("-C", repo, "branch", session_branch, base.to_s)
       return note("could not create session branch #{session_branch}: #{diagnose(create)}") unless create.success?
@@ -383,11 +413,12 @@ module SessionGit
       return note("expected to be on #{session_branch} but the checkout is on #{actual_branch.inspect}")
     end
 
-    commit_and_push(dir: repo, push_dir: repo, subject: subject, from: actual_branch, base: base, runner: runner)
+    commit_and_push(dir: repo, push_dir: repo, subject: subject, body: body, from: actual_branch, base: base,
+                     runner: runner)
   end
 
-  def commit_on_other_branch(repo:, subject:, branch_now:, runner:)
-    res = stage_and_commit(repo, subject, runner: runner)
+  def commit_on_other_branch(repo:, subject:, branch_now:, runner:, body: nil)
+    res = stage_and_commit(repo, subject, runner: runner, body: body)
     return note("commit rejected by commit-msg hook: #{diagnose(res)}") unless res.success?
 
     sha = short_sha(repo, runner: runner)
@@ -398,8 +429,8 @@ module SessionGit
   # shared tail. A non-fast-forward push (spec D3, "base moved ahead
   # independently") stays a Note: the commit itself already landed on the
   # session branch.
-  def commit_and_push(dir:, push_dir:, subject:, from:, base:, runner:)
-    res = stage_and_commit(dir, subject, runner: runner)
+  def commit_and_push(dir:, push_dir:, subject:, from:, base:, runner:, body: nil)
+    res = stage_and_commit(dir, subject, runner: runner, body: body)
     return note("commit rejected by commit-msg hook: #{diagnose(res)}") unless res.success?
 
     sha = short_sha(dir, runner: runner)
@@ -414,7 +445,7 @@ module SessionGit
 
   # --- pull request mode (spec D4) ------------------------------------------------
 
-  def commit_pull_request(repo:, subject:, day:, session:, store:, flow:, branch_now:, runner:, gh_runner:)
+  def commit_pull_request(repo:, subject:, day:, session:, store:, flow:, branch_now:, runner:, gh_runner:, body: nil)
     return note("nothing to commit") unless dirty?(repo, runner: runner)
     return note("summary is empty after truncation: no commit") if blank?(subject)
 
@@ -439,7 +470,7 @@ module SessionGit
       return note("could not check out branch #{branch}: #{diagnose(switch)}") unless switch.success?
     end
 
-    res = stage_and_commit(repo, subject, runner: runner)
+    res = stage_and_commit(repo, subject, runner: runner, body: body)
     outcome =
       if res.success?
         pull_request_outcome(repo: repo, subject: subject, branch: branch, base: base, gh_runner: gh_runner, runner: runner)

package/scripts/lib/session_ledger.rb

@@ -186,6 +186,130 @@ module SessionLedger
     "#{collapsed[0, 197]}..."
   end
 
+  # --- capture_worthy? (spec D2, D7; supersedes 298 D2(c)) -------------------
+
+  # One complete top-level harness envelope tag block: "<name ...>...</name>".
+  # Non-greedy (.*?) so sibling blocks are each matched on their own rather
+  # than one match spanning from the first block's opening tag all the way to
+  # the LAST block's closing tag (post-execution review item 3: an envelope
+  # on both sides of real work, "<system-reminder>...</system-reminder>\nfix
+  # the parser\n<task-notification>...</task-notification>", must not be
+  # read as one giant envelope swallowing the work in the middle).
+  ENVELOPE_BLOCK_RE = /<([A-Za-z][\w-]*)(?:\s[^>]*)?>.*?<\/\1>/m
+  private_constant :ENVELOPE_BLOCK_RE
+
+  # The whole prompt, case- and whitespace-insensitively, and nothing else
+  # (rule 3, D2): a trigger word inside a longer real instruction ("continue
+  # the dashboard fix and then release") must not match this.
+  BARE_TRIGGERS = %w[continue auto].freeze
+  private_constant :BARE_TRIGGERS
+
+  # Words whose presence marks a prompt as actionable work (rule 4's escape
+  # hatch, D2's accept bias). Deliberately excludes common nouns that also
+  # read as everyday verbs in casual remarks (e.g. "release", "ship", "plan"):
+  # including them would make ordinary conversation about a past release or
+  # plan look like a work request. Matched with an optional inflection suffix
+  # (post-execution review BLOCKER): the bare stems alone missed "fixed",
+  # "updated", "added", "reviewed", "implemented" -- exactly the past-tense
+  # and -ing forms real work summaries use.
+  WORK_MARKER_WORDS = %w[
+    fix add remove delete update upgrade implement write build create refactor
+    debug investigate review test deploy commit merge revert rename configure
+    install migrate document generate draft resolve help need want make change
+    setup
+  ].freeze
+  private_constant :WORK_MARKER_WORDS
+
+  WORK_MARKER_PHRASES = [
+    "can you", "could you", "would you", "let's", "let us", "set up", "look into", "figure out",
+  ].freeze
+  private_constant :WORK_MARKER_PHRASES
+
+  WORK_MARKER_RE = /\b(?:#{WORK_MARKER_WORDS.join("|")})(?:s|d|ed|ing)?\b/i
+  private_constant :WORK_MARKER_RE
+
+  # A first word that reads as an interrogative opener, checked case-
+  # insensitively against the prompt's first whitespace-separated token.
+  # Post-execution review BLOCKER: trimmed from the original, wider list
+  # (which also carried "how", "when", "where", "was", "were", "do", "did",
+  # "will", "shall", "should") down to words that open a genuine QUESTION at
+  # least as often as an ordinary command or request. Measured against 43
+  # invented and 27 real day-ledger prompts: the dropped words open ordinary
+  # work requests ("do the release now...", "when you are done, tag the
+  # release...", "will you push that branch...", "should I bump the version
+  # files...") far more often than they open a bare question worth rejecting.
+  QUESTION_STARTERS = %w[
+    what why who whom whose which is are am does can could would
+  ].freeze
+  private_constant :QUESTION_STARTERS
+
+  # A narrow set of retrospective-remark shapes ("that release went smoother
+  # than the last one"): comparative or evaluative observations about how
+  # something already went. Deliberately narrow (D2's accept bias): a broad
+  # "any declarative sentence with no recognized verb" rule would also catch
+  # ordinary work summaries like "harness text wins the pending line", which
+  # must stay accepted.
+  REMARK_PATTERNS = [
+    /\bwent\s+\w+\s+than\b/i,
+    /\bwent\s+(?:well|badly|smoothly|great|poorly|terribly)\b/i,
+  ].freeze
+  private_constant :REMARK_PATTERNS
+
+  # True iff nothing but harness envelope tag block(s) -- and whitespace --
+  # remain once every complete top-level block is stripped out. A prompt
+  # that is one envelope alone, or several envelopes with no other content,
+  # matches; a prompt carrying real work anywhere outside an envelope (before,
+  # after, or between several of them) does not.
+  def whole_prompt_envelope?(stripped)
+    stripped.gsub(ENVELOPE_BLOCK_RE, "").strip.empty?
+  end
+
+  def bare_trigger?(stripped)
+    BARE_TRIGGERS.include?(stripped.downcase)
+  end
+
+  def work_marker?(text)
+    return true if WORK_MARKER_RE.match?(text)
+
+    downcased = text.downcase
+    WORK_MARKER_PHRASES.any? { |p| downcased.include?(p) }
+  end
+
+  def interrogative?(stripped)
+    return true if stripped.end_with?("?")
+
+    first_word = stripped.split(/\s+/).first.to_s.downcase.gsub(/[^a-z]/, "")
+    QUESTION_STARTERS.include?(first_word)
+  end
+
+  def bare_remark?(stripped)
+    REMARK_PATTERNS.any? { |re| re.match?(stripped) }
+  end
+
+  # Internal helpers only: #capture_worthy? is the sole public contract
+  # (post-execution review item 9).
+  private_class_method :whole_prompt_envelope?, :bare_trigger?, :work_marker?, :interrogative?, :bare_remark?
+
+  # Whether `prompt` earns a pending checklist line (spec D2). Bias is
+  # ACCEPT: this rejects only on four named rules -- the 10-char floor (on
+  # its own collapsed copy), a whole-prompt harness envelope, a bare
+  # continue/auto trigger, and an interrogative or bare-remark prompt
+  # carrying no work marker -- and accepts everything else, including a
+  # work-shaped question and an envelope followed by real work. Takes the
+  # RAW prompt (not the sanitized/truncated line text) so rule 2 sees the
+  # prompt's true first character and multi-line shape.
+  def capture_worthy?(prompt)
+    raw = prompt.to_s
+    return false if sanitize_summary(raw).length < 10
+
+    stripped = raw.strip
+    return false if whole_prompt_envelope?(stripped)
+    return false if bare_trigger?(stripped)
+    return false if !work_marker?(stripped) && (interrogative?(stripped) || bare_remark?(stripped))
+
+    true
+  end
+
   # One LF-terminated checklist line, byte exact per spec D5. The state
   # marker is fixed width across all three states, which is what lets a later
   # promote or tick be a one-byte write at a known offset.

package/scripts/plastic-lock

@@ -70,6 +70,7 @@ until ARGV.empty?
   when "--model" then opts[:model] = ARGV.shift
   when "--thread" then opts[:thread] = ARGV.shift
   when "--mode" then opts[:mode] = ARGV.shift
+  when "--allow-inline" then opts[:allow_inline] = true
   when "--status" then opts[:status] = ARGV.shift
   else
     warn "unknown flag #{flag}"
@@ -154,7 +155,8 @@ end
 case verb
 when "arm"
   result = Arm.arm(intent_dir: dir, session: key, mode: opts[:mode] || "auto", home: home,
-                   harness: harness, agent: opts[:agent], model: opts[:model], thread: opts[:thread])
+                   harness: harness, agent: opts[:agent], model: opts[:model], thread: opts[:thread],
+                   allow_inline: opts[:allow_inline] || false)
   case result[:status]
   when :acquired, :owned
     wt = result[:worktree] || {}
@@ -178,6 +180,11 @@ when "arm"
   when :corrupt
     warn "plastic-lock: delivery.lock for intent #{intent_id} is unreadable; #{doctor_hint('fix the lock', hint_harness)}"
     exit 1
+  when :inline_refused
+    warn "plastic-lock: refusing to arm intent #{intent_id} from a conversation session " \
+         "(owner rule 2026-08-31: no inline intent delivery). Dispatch the delivery team " \
+         "instead (plastic-auto), or pass --allow-inline with explicit owner approval."
+    exit 1
   end
 when "status"
   lock = Lock.read(dir)

package/scripts/read-config

@@ -14,6 +14,9 @@ require_relative "lib/agent_models"
 DEFAULTS = {
   "version" => 3,
   "stale_threshold_days" => 3,
+  # Absolute token counts for a 1M window, 35 and 50 percent (intent 312, 296 D38).
+  "context_offer_tokens" => 350_000,
+  "context_insist_tokens" => 500_000,
   "execution_mode" => "subagent-driven",
   "hash_length" => 6,
   "hash_algorithm" => "sha256-base36",