@zalom/plastic 1.14.1 → 2.0.0-alpha.10

package/scripts/new-intent

@@ -21,22 +21,37 @@
 #              [--tags tag,tag] [--templates <dir>]
 #
 # Exit codes: 0 (born complete), 1 (scaffold failed self-validation or bad input).
+#
+# A second, unrelated mode (intent 297):
+#   new-intent --tmp [--store <dir>] [--day YYYYMMDD] [--author <name>] \
+#              [--templates <dir>]
+#
+# `--tmp` scaffolds the shared session intent day ledger under the global
+# store's `.sessions/<YYYYMMDD>/` instead of allocating a real intent id. It
+# is a thin CLI over SessionLedger.open_day (the single scaffold
+# implementation, spec D12) and never touches the id-allocation path above:
+# no folgezettel-id call, no actions/ or resources/ dirs, no sentinel
+# placeholders, no born savepoint stamp, no Links projection. Stdout is
+# exactly one line, `created <dir>` or `joined <dir>`; exit 0 either way,
+# exit 1 on bad input or failed self-validation.
 
 require "fileutils"
 require "date"
-require_relative "lib/bridge"
+require_relative "lib/savepoint"
 require_relative "lib/intent_validator"
 require_relative "lib/graph_rebuild"
 require_relative "lib/links_projection"
 require_relative "lib/links_section"
 require_relative "lib/store_discovery"
+require_relative "lib/session_ledger"
 
 # --- Explicit flag parsing (no eval, no global injection) ------------------
 
 def parse_args(argv)
   opts = {
     store: nil, intent: nil, slug: nil, parent: nil,
-    author: "claude-code", sources: [], tags: [], templates: nil
+    author: "claude-code", sources: [], tags: [], templates: nil,
+    tmp: false, day: nil
   }
   i = 0
   while i < argv.length
@@ -50,6 +65,8 @@ def parse_args(argv)
     when "--sources"   then opts[:sources] = split_list(argv[i += 1])
     when "--tags"      then opts[:tags] = split_list(argv[i += 1])
     when "--templates" then opts[:templates] = argv[i += 1]
+    when "--tmp"       then opts[:tmp] = true
+    when "--day"       then opts[:day] = argv[i += 1]
     else
       abort "new-intent: unknown argument #{arg.inspect}"
     end
@@ -253,8 +270,50 @@ def project_links_for(file_path, referer_store_key, maps)
   true
 end
 
+# The --tmp branch (intent 297, spec D1): scaffold the shared session intent
+# day ledger instead of a real intent. A thin CLI over
+# SessionLedger.open_day, the single scaffold implementation (spec D12); this
+# method never allocates a folgezettel id, never creates actions/ or
+# resources/, never writes a sentinel placeholder, never stamps a savepoint
+# line, and never runs the Links projection build.
+def run_tmp(opts)
+  { intent: "--intent", slug: "--slug", parent: "--parent" }.each do |key, flag|
+    abort "new-intent: #{flag} is not valid with --tmp" if opts[key] && !opts[key].to_s.empty?
+  end
+  abort "new-intent: --sources is not valid with --tmp" unless opts[:sources].empty?
+  abort "new-intent: --tags is not valid with --tmp" unless opts[:tags].empty?
+
+  store = opts[:store] ? expand(opts[:store]) : expand(File.join(ENV.fetch("PLASTIC_HOME", "~/.plastic"), "store"))
+  templates = opts[:templates] ? expand(opts[:templates]) : default_templates_dir
+  abort "new-intent: templates dir not found: #{templates}" unless Dir.exist?(templates)
+
+  day = opts[:day] || SessionLedger.day_id
+  unless SessionLedger.valid_day_id?(day)
+    abort "new-intent: --day must be eight digits parsing as a real date, got #{opts[:day].inspect}"
+  end
+
+  result = SessionLedger.open_day(store: store, day: day, templates: templates, author: opts[:author], now: Time.now)
+
+  plastic_home, = store_context(store)
+  known_stores = StoreDiscovery.known_slugs(plastic_home)
+  validation = IntentValidator.validate(result[:dir], known_stores: known_stores)
+  unless validation[:ok]
+    warn "new-intent: scaffolded day ledger is NOT born complete:"
+    validation[:missing].each { |f| warn "  missing field: #{f}" }
+    validation[:errors].each { |e| warn "  #{e}" }
+    exit 1
+  end
+
+  puts "#{result[:created] ? "created" : "joined"} #{result[:dir]}"
+  exit 0
+end
+
 def main(argv)
   opts = parse_args(argv)
+  return run_tmp(opts) if opts[:tmp]
+
+  abort "new-intent: --day is only valid with --tmp" if opts[:day]
+
   abort "new-intent: --store is required" if opts[:store].nil? || opts[:store].empty?
   abort "new-intent: --intent is required" if opts[:intent].nil? || opts[:intent].empty?
   abort "new-intent: --slug is required" if opts[:slug].nil? || opts[:slug].empty?
@@ -338,7 +397,7 @@ def main(argv)
     template_path = File.join(templates, name)
     body = File.exist?(template_path) ? File.read(template_path) : ""
     body = render_tokens(body, { "INTENT_NAME" => opts[:intent] })
-    File.write(File.join(intent_dir, name), "#{Bridge::PLACEHOLDER_SENTINEL}\n#{body}")
+    File.write(File.join(intent_dir, name), "#{Savepoint::PLACEHOLDER_SENTINEL}\n#{body}")
   end
 
   # 6. Stamp the born savepoint line (intent 81). The first ledger line is the
@@ -347,7 +406,7 @@ def main(argv)
   # sessions / harnesses). The intent file is never a sentinel placeholder, so
   # append_savepoint records `What  {id}--{slug}.md`. Idempotent: a later gate
   # fire adds nothing.
-  Bridge.append_savepoint(intent_dir, intent_file)
+  Savepoint.append_savepoint(intent_dir, intent_file)
 
   # 7. Self-validate (frontmatter + sanctioned sections), including that every
   # sources/chain cross-store token names a real store (intent 189 D3).

package/scripts/plastic-lock

@@ -2,19 +2,29 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 #
-# plastic-lock: inspect and repair the durable delivery lock (intent 108, D5),
-# and take/free per-artifact claim tokens (intent 111 D1/D5).
+# plastic-lock: take, inspect, repair, and give back the durable delivery lock
+# (intent 108, D5; intent 307), and take/free per-artifact claim tokens
+# (intent 111 D1/D5).
 #
-# Usage: plastic-lock <status|who|fix|release|reclaim|delegate|claim|release-claim>
+# Usage: plastic-lock <arm|status|who|fix|release|reclaim|delegate|claim|release-claim>
 #          [--intent-dir DIR] [--session SID] [--delegate SID] [--artifact NAME]
+#          [--harness claude|codex] [--agent NAME] [--model MODEL] [--thread ID]
+#          [--mode auto|guided] [--status finished|failed]
 #
 # Verbs:
+#   arm           take the intent for this session (intent 307): acquire
+#                 delivery.lock stamped with --mode (default auto) and the
+#                 provenance flags, provision the code worktree, and point the
+#                 session at the intent; exit 1 on a held, stale, excluded, or
+#                 corrupt lock with the resolving doctor hint
 #   who           compact, read-only durable owner/activity view
-#   status        report the lock file, the bridge cache, their agreement,
-#                 and any live per-artifact claims
-#   fix           idempotent repair: rebuild lock + bridge from disk truth for
-#                 the current session; never touches a fresh foreign lock
-#   release       owner clears the lock (End tail / abandoning a boarding)
+#   status        report the lock file, its freshness, the derived worktree,
+#                 whether this session's pointer names the intent, and any
+#                 live per-artifact claims
+#   fix           idempotent repair of the lock for the current session; never
+#                 touches a fresh foreign lock
+#   release       owner clears the lock and points the session back at the day
+#                 ledger (End tail / abandoning a boarding)
 #   reclaim       explicit takeover of a stale lock, audited in savepoint.md
 #   delegate      owner registers a subagent session under the lock (D4)
 #   claim         acquire the named --artifact's claim token (intent 111);
@@ -22,15 +32,23 @@
 #                 including this same session; takes over a stale claim
 #   release-claim free the named --artifact's claim token
 #
-# Without --intent-dir the intent is resolved from this session's bridge.
-# Exit 0 on success/report; exit 1 when the verb is blocked (held elsewhere).
+# Without --intent-dir the intent is resolved from this session's pointer
+# (~/.plastic/store/.tmp/<session>/current) when it names an intent id, looked
+# up in the working directory's project store and then the global store. The
+# /tmp bridge JSON this CLI used to resolve through was removed in 2.0
+# (intent 307). Exit 0 on success/report; exit 1 when the verb is blocked.
 
 require "json"
+require "yaml"
 require_relative "lib/bridge"
 require_relative "lib/lock"
+require_relative "lib/arm"
+require_relative "lib/session_ledger"
+
+VERBS = %w[arm status who fix release reclaim delegate claim release-claim].freeze
 
 def usage!
-  warn "usage: plastic-lock <status|who|fix|release|reclaim|delegate|claim|release-claim> " \
+  warn "usage: plastic-lock <#{VERBS.join('|')}> " \
        "[--intent-dir DIR] [--session SID] [--delegate SID] [--artifact NAME] " \
        "[--harness claude|codex] [--agent NAME] [--model MODEL] [--thread ID] " \
        "[--mode auto|guided] [--status finished|failed]"
@@ -38,7 +56,7 @@ def usage!
 end
 
 verb = ARGV.shift
-usage! unless %w[status who fix release reclaim delegate claim release-claim].include?(verb)
+usage! unless VERBS.include?(verb)
 
 opts = {}
 until ARGV.empty?
@@ -52,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}"
@@ -64,15 +83,29 @@ session = opts[:session]
 session = ENV["CLAUDE_CODE_SESSION_ID"] if session.nil? || session.strip.empty?
 harness = opts[:harness]
 hint_harness = harness || "claude"
+# The plastic home every hook uses (PLASTIC_HOME, else ~/.plastic); Arm takes the
+# OS home above it, the same convention Worktree resolves projects.yml from.
+plastic_home_env = ENV["PLASTIC_HOME"].to_s.strip
+home = plastic_home_env.empty? ? Dir.home : File.dirname(File.expand_path(plastic_home_env))
+
+# The stores this session's pointer is resolved against: the project store of
+# the working directory (projects.yml, longest path match), then the global one.
+def candidate_stores(home, cwd)
+  plastic_home = File.join(home, ".plastic")
+  stores = []
+  slug = SessionLedger.project_slug(cwd, plastic_home: plastic_home)
+  stores << File.join(plastic_home, "projects", slug, "store") if slug && slug != "global"
+  stores << File.join(plastic_home, "store")
+  stores
+end
 
 dir = opts[:dir]
 if dir.nil? || dir.strip.empty?
-  if verb == "who"
-    warn "plastic-lock: who is strictly durable-state only; pass --intent-dir <intent dir>"
+  if %w[who arm].include?(verb)
+    warn "plastic-lock: #{verb} needs --intent-dir <intent dir>"
     exit 1
   end
-  bridge = Bridge.discover_bridge(session: session, cwd: Dir.pwd)
-  dir = Bridge.bridge_intent_dir(bridge)
+  dir = Arm.intent_dir_from_pointer(session, home: home, stores: candidate_stores(home, Dir.pwd))
 end
 if dir.nil?
   warn "plastic-lock: no intent resolved; pass --intent-dir <intent dir>"
@@ -85,7 +118,7 @@ if verb == "who"
   basename = File.basename(dir)
   intent_id, slug = basename.split("--", 2)
   display = ->(value) { value.nil? || value.to_s.strip.empty? || value == "unknown" ? "Unknown" : value.to_s }
-  harness = ->(value) {
+  harness_name = ->(value) {
     shown = display.call(value)
     shown == "Unknown" ? shown : shown.sub(/\A./) { |char| char.upcase }
   }
@@ -99,12 +132,12 @@ if verb == "who"
 
   puts "#{intent_id} · #{slug || basename}"
   puts "State: #{view['state']}"
-  puts "Controller: #{display.call(owner['agent'])} via #{harness.call(owner['harness'])}"
+  puts "Controller: #{display.call(owner['agent'])} via #{harness_name.call(owner['harness'])}"
   puts "Session: #{display.call(view['owner_session'])}"
   puts "Heartbeat: #{view['heartbeat_at'] || 'none'}"
   puts "Claims: #{claim_text.empty? ? 'none' : claim_text.join(', ')}"
   if delegate
-    puts "Delegate: #{display.call(delegate['agent'])} via #{harness.call(delegate['harness'])}, #{display.call(delegate['status'])}"
+    puts "Delegate: #{display.call(delegate['agent'])} via #{harness_name.call(delegate['harness'])}, #{display.call(delegate['status'])}"
   else
     puts "Delegate: none"
   end
@@ -113,31 +146,65 @@ end
 
 intent_id = Bridge.intent_id_from_dir(dir)
 store = File.dirname(dir)
-name = File.basename(dir)
-key = Bridge.resolve_session(session, intent_id: intent_id, store: store)
+key = Arm.resolve_session(session, store: store, intent_id: intent_id)
+
+def doctor_hint(verb_text, harness)
+  "run #{Lock.skill_ref('plastic-doctor', harness: harness)} #{verb_text}"
+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],
+                   allow_inline: opts[:allow_inline] || false)
+  case result[:status]
+  when :acquired, :owned
+    wt = result[:worktree] || {}
+    puts JSON.pretty_generate(
+      "intent_dir" => dir, "session" => result[:session], "status" => result[:status].to_s,
+      "run_mode" => result[:lock] && result[:lock]["run_mode"],
+      "worktree" => wt, "pointer" => result[:pointer]
+    )
+  when :held
+    warn "plastic-lock: delivery lock for intent #{intent_id} is held by session " \
+         "#{result[:lock] && result[:lock]['owner_session']}; #{doctor_hint('check the lock status', hint_harness)}"
+    exit 1
+  when :stale
+    warn "plastic-lock: delivery lock for intent #{intent_id} is stale (owner " \
+         "#{result[:lock] && result[:lock]['owner_session']}); #{doctor_hint('reclaim the lock to take it over with an audit', hint_harness)}"
+    exit 1
+  when :excluded
+    warn "plastic-lock: a #{result[:lock] && result[:lock]['type']} lock is active on intent " \
+         "#{intent_id}; #{doctor_hint('check the lock status', hint_harness)}"
+    exit 1
+  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)
-  bridge = Bridge.read(key, intent_id: intent_id)
+  pointer = Arm.read_pointer(key, home: home)
   report = {
     "intent_dir" => dir,
     "session" => key,
     "lock" => lock,
     "lock_fresh" => Lock.fresh?(dir),
     "lock_corrupt" => Lock.corrupt?(dir),
-    "bridge_present" => !bridge.nil?,
-    "agreement" => (lock && bridge) ?
-      (lock["owner_session"] == bridge.dig("lock", "owner_session")) : nil,
+    "worktree" => Arm.worktree_block(intent_dir: dir, home: home),
+    "pointer" => pointer,
+    "pointer_names_intent" => pointer == intent_id,
     "claims" => Claim.claims_status(dir),
   }
   puts JSON.pretty_generate(report)
 when "fix"
-  report = Bridge.repair_lock(key, intent_id: intent_id, intent_dir: dir,
-                              store: store, name: name, harness: harness,
-                              agent: opts[:agent], model: opts[:model], thread: opts[:thread],
-                              run_mode: opts[:mode],
-                              hint_harness: hint_harness)
+  report = Arm.repair(intent_dir: dir, session: key, home: home, harness: harness,
+                      agent: opts[:agent], model: opts[:model], thread: opts[:thread],
+                      run_mode: opts[:mode], hint_harness: hint_harness)
   puts JSON.pretty_generate(report)
   unless report["status"] == "repaired"
     warn "plastic-lock: #{report['status']} by #{report['owner']}" \
@@ -150,12 +217,7 @@ when "release"
     warn "plastic-lock: not the owner; run plastic-lock status"
     exit 1
   end
-  data = Bridge.read(key, intent_id: intent_id)
-  if data
-    data["lock"] = { "owner_session" => nil, "acquired_at" => nil,
-                     "host" => nil, "type" => nil, "delegates" => [] }
-    Bridge.write(key, data)
-  end
+  Arm.reset_pointer(key, intent_id, home: home)
   puts "released (#{result})"
 when "reclaim"
   status, lock_data = Lock.takeover(dir, session: key, harness: harness,
@@ -166,11 +228,9 @@ when "reclaim"
          "back off (no silent reclaim)"
     exit 1
   end
-  report = Bridge.repair_lock(key, intent_id: intent_id, intent_dir: dir,
-                              store: store, name: name, harness: harness,
-                              agent: opts[:agent], model: opts[:model], thread: opts[:thread],
-                              run_mode: opts[:mode],
-                              hint_harness: hint_harness)
+  report = Arm.repair(intent_dir: dir, session: key, home: home, harness: harness,
+                      agent: opts[:agent], model: opts[:model], thread: opts[:thread],
+                      run_mode: opts[:mode], hint_harness: hint_harness)
   puts JSON.pretty_generate(report)
 when "delegate"
   usage! if opts[:delegate].nil?

package/scripts/promote-session-item

@@ -0,0 +1,150 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# promote-session-item (intent 301): turn one session day-ledger line into a
+# registered intent through scripts/new-intent (never hand-authored), record
+# the day of origin in the new intent, and mark the line promoted.
+#
+# Usage:
+#   promote-session-item --day <YYYYMMDD> --match <substring> [--session <id>]
+#                        [--store <dir>] [--project <slug>] [--templates <dir>]
+#                        [--plastic-home <dir>] [--no-reindex]
+#
+# Target: the newest open line, else the newest pending line, whose summary
+# contains --match, tagged with --session when given, any session otherwise.
+# The intent lands in the project's store when --project names a registered
+# project, else in --store ($PLASTIC_HOME/store by default). No graph edge to
+# the day id is written (the day ledger is not a store node); the origin is
+# the `session_day:` frontmatter key plus a line under ## Context.
+#
+# Exit codes: 0 promoted (prints the intent dir last), 1 new-intent failed,
+# 2 usage error or nothing to promote.
+
+require "open3"
+require "yaml"
+require_relative "lib/session_ledger"
+require_relative "lib/session_backfill"
+require_relative "lib/store_provisioning"
+
+def usage_abort(message)
+  warn "promote-session-item: #{message}"
+  exit 2
+end
+
+def next_value!(argv, i, flag)
+  value = argv[i + 1]
+  usage_abort("#{flag} needs a value") if value.nil? || value.start_with?("--")
+  value
+end
+
+opts = { day: nil, match: nil, session: nil, store: nil, project: nil, templates: nil,
+         plastic_home: nil, reindex: true }
+i = 0
+while i < ARGV.length
+  case ARGV[i]
+  when "--day"          then opts[:day] = next_value!(ARGV, i, "--day"); i += 1
+  when "--match"        then opts[:match] = next_value!(ARGV, i, "--match"); i += 1
+  when "--session"      then opts[:session] = next_value!(ARGV, i, "--session"); i += 1
+  when "--store"        then opts[:store] = next_value!(ARGV, i, "--store"); i += 1
+  when "--project"      then opts[:project] = next_value!(ARGV, i, "--project"); i += 1
+  when "--templates"    then opts[:templates] = next_value!(ARGV, i, "--templates"); i += 1
+  when "--plastic-home" then opts[:plastic_home] = next_value!(ARGV, i, "--plastic-home"); i += 1
+  when "--no-reindex"   then opts[:reindex] = false
+  else usage_abort("unknown argument #{ARGV[i].inspect}")
+  end
+  i += 1
+end
+
+usage_abort("--day is required") if opts[:day].nil?
+usage_abort("--day must be a real calendar date, YYYYMMDD") unless SessionLedger.valid_day_id?(opts[:day])
+usage_abort("--match is required") if opts[:match].nil? || opts[:match].empty?
+
+plastic_home = File.expand_path(opts[:plastic_home] || ENV.fetch("PLASTIC_HOME", "~/.plastic"))
+store = opts[:store] || File.join(plastic_home, "store")
+templates = opts[:templates] || File.expand_path("../templates", __dir__)
+session = opts[:session] ? SessionLedger.short_session_id(opts[:session]) : nil
+
+target_store = store
+if opts[:project]
+  projects = StoreProvisioning.load_projects(plastic_home)
+  usage_abort("--project #{opts[:project]} is not a registered project") unless projects.key?(opts[:project])
+  target_store = File.join(plastic_home, "projects", opts[:project], "store")
+end
+
+# --- pick the target line ---------------------------------------------------
+
+day_dir = SessionLedger.day_dir(store, opts[:day])
+checklist = SessionLedger.checklist_path(store, opts[:day])
+items = SessionBackfill.read_items(day_dir)
+candidates = items.select do |item|
+  (session.nil? || item[:session] == session) && item[:summary].include?(opts[:match])
+end
+target = candidates.reverse.find { |item| item[:state] == :open } ||
+         candidates.reverse.find { |item| item[:state] == :pending }
+usage_abort("nothing to promote in #{opts[:day]} matching #{opts[:match].inspect}") if target.nil?
+
+# --- scaffold through new-intent ---------------------------------------------
+
+def slug_for(summary)
+  words = summary.downcase.gsub(/[^a-z0-9]+/, "-").gsub(/\A-+|-+\z/, "").split("-").reject(&:empty?)
+  slug = words.first(5).join("-")
+  slug.empty? ? "item" : slug
+end
+
+new_intent = File.expand_path("new-intent", __dir__)
+out, err, status = Open3.capture3({ "RUBYOPT" => nil }, RbConfig.ruby, new_intent,
+                                  "--store", target_store, "--intent", target[:summary],
+                                  "--slug", slug_for(target[:summary]), "--templates", templates)
+unless status.success?
+  warn "promote-session-item: new-intent failed:"
+  warn err
+  warn out
+  exit 1
+end
+intent_dir = out.lines.last.to_s.strip
+usage_abort("new-intent printed no intent dir") if intent_dir.empty? || !Dir.exist?(intent_dir)
+intent_id = File.basename(intent_dir).split("--", 2).first
+
+# --- record the origin in the new intent (one atomic rewrite) -----------------
+
+intent_file = File.join(intent_dir, "#{File.basename(intent_dir)}.md")
+content = File.read(intent_file)
+parts = content.split(/^(---\s*\n)/, 3)
+if parts.length >= 4
+  parts[2] += "session_day: \"#{opts[:day]}\"\n"
+  content = parts[0] + parts[1] + parts[2] + parts[3] + parts[4].to_s
+end
+origin = "Promoted from the session ledger of #{opts[:day]}: #{target[:summary]}\n"
+content = content.sub(/^## Context\n/) { |heading| heading + origin }
+SessionBackfill.write_atomic(intent_dir, File.basename(intent_file), content)
+
+# --- register the intent under ## Future in the store's INDEX.md ----------------
+
+def register_in_index(index_path, intent_id, intent_dir, summary)
+  return unless File.exist?(index_path)
+
+  relative = "store/#{File.basename(intent_dir)}/#{File.basename(intent_dir)}.md"
+  entry = "- [#{intent_id} - #{summary}](#{relative}) - promoted from a session ledger\n"
+  content = File.read(index_path)
+  return if content.include?("(#{relative})")
+
+  updated = content.sub(/^## Future\n(?:\(no future intents\)\n)?/) { |heading| heading.sub(/\(no future intents\)\n/, "") + entry }
+  SessionBackfill.write_atomic(File.dirname(index_path), File.basename(index_path), updated)
+end
+
+register_in_index(File.join(File.dirname(target_store), "INDEX.md"), intent_id, intent_dir, target[:summary])
+
+# --- mark the line, note it, reindex ---------------------------------------------
+
+SessionLedger.set_state(checklist, from: target[:state], to: :promoted, session: target[:session],
+                        match: target[:summary])
+SessionLedger.append_line(SessionLedger.savepoint_path(store, opts[:day]),
+                          SessionLedger.savepoint_line("Note", target[:session], target[:project],
+                                                       "promoted \"#{target[:summary]}\" to intent #{intent_id}",
+                                                       now: Time.now))
+if opts[:reindex]
+  qmd_sync = File.expand_path("qmd-sync", __dir__)
+  system({ "RUBYOPT" => nil }, RbConfig.ruby, qmd_sync, "reindex", out: File::NULL, err: File::NULL) if File.exist?(qmd_sync)
+end
+puts intent_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",

package/scripts/rebuild-graph

@@ -82,7 +82,7 @@ class RebuildGraph
   end
 
   # Registered projects.yml slugs with no store directory on disk (legal;
-  # plastic-store-provisioning exists for exactly this state). Reported in the audit
+  # the plastic-doctor provisioning section exists for exactly this state). Reported in the audit
   # (intent 189 D5) so this never looks like a silent empty store.
   def missing_stores
     discovery[:missing]

package/scripts/report-screen

@@ -0,0 +1,120 @@
+#!/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]
+#   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_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 nearest git tag
+# reachable from the repo this script lives in, so `render_delivered`'s
+# version field and the `ship` evidence row are never invented. The pure
+# module never reads git itself; this is injected as `tag_reader:`.
+def git_tag_reader(repo_root)
+  lambda do |_intent_dir|
+    return nil unless File.exist?(File.join(repo_root, ".git"))
+    tag = `git -C #{repo_root} describe --tags --abbrev=0 2>/dev/null`.strip
+    tag.empty? ? nil : tag
+  end
+end
+
+args = ARGV.dup
+verb = args.shift
+changed = nil
+ansi = false
+template_path = 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 "--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)
+  repo_root = File.expand_path("..", __dir__)
+  out = ReportScreen.render_delivered(intent_dir: intent_dir, tag_reader: git_tag_reader(repo_root))
+  $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/roadmap-next

@@ -4,10 +4,10 @@
 
 # roadmap-next - thin CLI over RoadmapQueue (intent 148).
 #
-# The auto loop and plastic-roadmap-continuing both call this instead of ranking roadmap
+# The auto loop and plastic-intent-continuing both call this instead of ranking roadmap
 # liveness in prose. Queue mode (default) is for the auto loop: it breaks a tie
 # deterministically and reports the winner's frontier state. Which mode (--which) is for
-# plastic-roadmap-continuing: it returns tie_candidates so the skill's single ask can resolve
+# plastic-intent-continuing: it returns tie_candidates so the skill's roadmap route can resolve
 # a genuine tie.
 #
 # Usage: