@zalom/plastic 1.14.1 → 2.0.0-alpha.10

package/scripts/rollback.rb

@@ -82,8 +82,6 @@ class Rollback < InstallerCore
     File.exist?(path) ? File.read(path).strip : nil
   end
 
-  private
-
   def flag_value(argv, name)
     i = argv.index(name)
     return nil unless i && argv[i + 1]
@@ -93,11 +91,58 @@ class Rollback < InstallerCore
   def switch_to(target, current)
     action = action_for(target, current)
     puts "#{action == "downgrade" ? "\u{23ea}" : "\u{23e9}"}  #{current} \u{2192} #{target} (#{action})"
-    cmd = ["npx", "#{PKG}@#{target}", "install", "--reinstall", "--ledger-action", action, "--claude"]
+    prepare_switch(target, current)
+    cmd = ["npx", "#{PKG}@#{target}", "install", "--reinstall", "--ledger-action", action, *harness_flags]
     puts "  $ #{cmd.join(" ")}"
     system(*cmd) ? 0 : 1
   end
 
+  # Before handing off to an older package (a downgrade), strip Plastic's own current hook
+  # registrations from every installed harness (intent 310, cut-inventory R2). The older
+  # installer purges only the names its own registry knows, so an entry this version
+  # registered would otherwise survive while the older manifest diff deletes its launcher,
+  # and the older doctor would then report an unowned plastic- command. The older installer
+  # registers its own set fresh on the cleaned file. Returns the paths it stripped.
+  def prepare_switch(target, current)
+    return [] unless action_for(target, current) == "downgrade"
+
+    stripped = []
+    installed_agents.each do |key|
+      agent = agents.find { |a| a[:key] == key }
+      next unless agent
+
+      case key
+      when "claude"
+        path = File.join(agent[:dir], "settings.json")
+        if File.exist?(path)
+          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)
+          remove_codex_hooks(path)
+          stripped << path
+        end
+      end
+    end
+    stripped
+  end
+
+  # The install flags for every harness with a per-agent record (intent 310); Claude alone
+  # when nothing is recorded, matching the first-install default.
+  def harness_flags
+    keys = installed_agents
+    keys = ["claude"] if keys.empty?
+    keys.map { |k| "--#{k}" }
+  end
+
   def print_table(ledger, current)
     puts "\nPlastic version history (versions.json — append-only):\n\n"
     puts "    %-22s %-10s %s" % ["version", "action", "at"]

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/scaffold-intent

@@ -2,46 +2,38 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
-# scaffold-intent (intent 213) - one CLI, three subcommands, each writes one lifecycle
-# artifact by copying or mechanically deriving it from an already-committed source. Every
-# field it writes is a verbatim copy or a mechanical derivation (a `git diff --stat`, a
-# supplied file's contents) of an already-committed artifact; no subcommand interprets or
-# invents prose. A field it cannot derive mechanically is left as the template's own stub
-# text instead of being guessed at.
+# scaffold-intent (intent 213; one verb since intent 308) - write an intent's judgment
+# documents from its record. `backfill` fills spec.md, plan.md, actions/ACTION_1.md, and
+# outcome.md wherever the file is missing or still the scaffold placeholder, from the
+# intent file, checklist.md, and the diff (BackfillIntent). Every section it writes is a
+# verbatim copy or a mechanical rendering of an already-committed artifact; a section with
+# no source keeps the template's own stub text. A hand-written file is never touched, and
+# there is no force flag: real content is edited by hand or not at all.
 #
-# Usage:
-#   scaffold-intent spec|checklist|outcome --store <path> --id <intent_id> [--force]
-#     [--test-summary <path>]   (outcome subcommand only)
+# `scripts/end-intent` runs the same writer at every close, so this CLI exists for the
+# doctor fix hint (backfilled_complete) and for filling an intent by hand before its close.
 #
-# Subcommand is the first positional argument. --store and --id are required for every
-# subcommand. --test-summary is valid only on the outcome subcommand; on spec or
-# checklist, or naming a path that does not exist, it is a usage error (exit 1). No other
-# flags exist: --store, --id, --force, and --test-summary (outcome only) are the whole
-# shipped surface (D5, a one-way door).
+# Usage:
+#   scaffold-intent backfill --store <path> --id <intent_id> --disposition delivered|abandoned
+#                            [--summary <text>]
 #
 # Exit codes:
-#   0  scaffolded
+#   0  written, or nothing left to write
 #   1  usage or path-resolution failure
-#   2  refused to overwrite real content without --force
-#   3  a prerequisite committed artifact is missing or still sentinel
-#
-# The actions/ rule (intent 133a, D11): scaffold-intent does not scaffold actions/ in any
-# form. Actions require judgment and stay entirely with the planner. No subcommand
-# creates the directory, writes a .gitkeep, or writes a sentinel-only ACTION_*.md.
+#   3  a source is unusable (the intent file is missing)
 #
-# outcome is an end-of-Exec step. Run it once the diff and the test summary exist, right
-# before plastic-intent-ending writes the narrative. Writing outcome.md makes the intent
-# read as Done to any stage-derived display (Bridge.derive_stage keys on outcome.md's
-# presence). This does NOT purge a bridge:
-# Bridge.purge_done_bridges keys on INDEX Active status plus lock presence, never on the
-# derived stage.
+# The spec, checklist, and outcome subcommands, --force, and --test-summary were removed
+# in 2.0 (intent 308): the backfill writer covers their two derivable targets and the
+# outcome diffstat, and nothing else called them.
 
 require_relative "lib/scaffold_intent"
+require_relative "lib/backfill_intent"
 
-SUBCOMMANDS = %w[spec checklist outcome].freeze
+SUBCOMMANDS = %w[backfill].freeze
+DISPOSITIONS = %w[delivered abandoned].freeze
 
 def parse_args(argv)
-  opts = { subcommand: nil, store: nil, id: nil, force: false, test_summary: nil }
+  opts = { subcommand: nil, store: nil, id: nil, disposition: nil, summary: nil }
   args = argv.dup
   opts[:subcommand] = args.shift
 
@@ -49,10 +41,10 @@ def parse_args(argv)
   while i < args.length
     arg = args[i]
     case arg
-    when "--store"        then opts[:store] = args[i += 1]
-    when "--id"            then opts[:id] = args[i += 1]
-    when "--force"         then opts[:force] = true
-    when "--test-summary"  then opts[:test_summary] = args[i += 1]
+    when "--store"       then opts[:store] = args[i += 1]
+    when "--id"          then opts[:id] = args[i += 1]
+    when "--disposition" then opts[:disposition] = args[i += 1]
+    when "--summary"     then opts[:summary] = args[i += 1]
     else
       usage_abort("unknown argument #{arg.inspect}")
     end
@@ -62,8 +54,8 @@ def parse_args(argv)
 end
 
 def usage
-  "usage: scaffold-intent spec|checklist|outcome --store <store_path> --id <intent_id> " \
-    "[--force] [--test-summary <path>]"
+  "usage: scaffold-intent backfill --store <store_path> --id <intent_id> " \
+    "--disposition delivered|abandoned [--summary <text>]"
 end
 
 def usage_abort(message)
@@ -75,11 +67,11 @@ end
 def main(argv)
   opts = parse_args(argv)
 
-  usage_abort("subcommand must be one of #{SUBCOMMANDS.join('|')}") unless SUBCOMMANDS.include?(opts[:subcommand])
+  usage_abort("subcommand must be #{SUBCOMMANDS.join('|')}") unless SUBCOMMANDS.include?(opts[:subcommand])
   usage_abort("--store is required") if opts[:store].nil? || opts[:store].empty?
   usage_abort("--id is required") if opts[:id].nil? || opts[:id].empty?
-  if opts[:test_summary] && opts[:subcommand] != "outcome"
-    usage_abort("--test-summary is valid only on the outcome subcommand")
+  unless DISPOSITIONS.include?(opts[:disposition])
+    usage_abort("--disposition must be one of #{DISPOSITIONS.join('|')}")
   end
 
   store = ScaffoldIntent.expand(opts[:store])
@@ -88,33 +80,15 @@ def main(argv)
   intent_dir, err = ScaffoldIntent.resolve_intent_dir(store, opts[:id])
   usage_abort(err) if intent_dir.nil?
 
-  test_summary_path = nil
-  if opts[:test_summary]
-    test_summary_path = ScaffoldIntent.expand(opts[:test_summary])
-    usage_abort("--test-summary path does not exist: #{test_summary_path}") unless File.exist?(test_summary_path)
-  end
+  result = BackfillIntent.run(intent_dir: intent_dir, store: store, id: opts[:id],
+                              disposition: opts[:disposition], summary: opts[:summary])
 
-  result =
-    case opts[:subcommand]
-    when "spec"
-      ScaffoldIntent.scaffold_spec(intent_dir: intent_dir, force: opts[:force])
-    when "checklist"
-      ScaffoldIntent.scaffold_checklist(intent_dir: intent_dir, force: opts[:force])
-    when "outcome"
-      ScaffoldIntent.scaffold_outcome(intent_dir: intent_dir, force: opts[:force], store: store,
-                                      id: opts[:id], test_summary: test_summary_path)
-    end
-
-  if result[:message]
-    if result[:code] == 0
-      puts result[:message]
-    else
-      warn "scaffold-intent: #{result[:message]}"
-    end
-  end
-  puts result[:path] if result[:path]
+  result[:written].each { |rel| puts "scaffold-intent: backfilled #{File.join(intent_dir, rel)}" }
+  result[:skipped].each { |rel| puts "scaffold-intent: kept #{rel} (real content)" }
+  result[:notes].each { |note| warn "scaffold-intent: #{note}" }
+  puts "scaffold-intent: nothing to backfill" if result[:written].empty? && result[:notes].empty?
 
-  exit result[:code]
+  exit(result[:notes].any? { |n| n.include?("intent file is missing") } ? 3 : 0)
 end
 
 main(ARGV) if $PROGRAM_NAME == __FILE__

package/scripts/session-commit

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# session-commit (intent 300) - makes one commit for a verified checklist
+# item on the right branch of the repo that contains `--cwd`, applying the
+# branch model and per-repo flow settings in `scripts/lib/session_git.rb`.
+# Idempotent and fail-open: no repository, a detached HEAD, a clean tree, an
+# agent-owned branch, a refused push, a missing `gh`, or a rejected
+# commit-msg hook all degrade to no commit plus a Note savepoint line,
+# never a non-zero exit (spec D1).
+#
+# Usage:
+#   session-commit --cwd <dir> --summary <text> [--session <id>] [--day <YYYYMMDD>]
+#                   [--store <dir>] [--plastic-home <dir>]
+#
+# Exit codes:
+#   0 - always, except a usage error
+#   2 - usage error (missing --cwd or --summary); nothing is written
+
+require "fileutils"
+require_relative "lib/session_git"
+require_relative "lib/session_ledger"
+
+def usage_abort(message)
+  warn "session-commit: #{message}"
+  exit 2
+end
+
+def next_value!(argv, i, flag)
+  usage_abort("#{flag} requires a value") if i + 1 >= argv.length
+  argv[i + 1]
+end
+
+def parse_args(argv)
+  opts = { cwd: nil, summary: nil, session: nil, day: nil, store: nil, plastic_home: nil }
+  i = 0
+  while i < argv.length
+    arg = argv[i]
+    case arg
+    when "--cwd"          then opts[:cwd] = next_value!(argv, i, arg); i += 1
+    when "--summary"      then opts[:summary] = next_value!(argv, i, arg); i += 1
+    when "--session"      then opts[:session] = next_value!(argv, i, arg); i += 1
+    when "--day"          then opts[:day] = next_value!(argv, i, arg); i += 1
+    when "--store"        then opts[:store] = next_value!(argv, i, arg); i += 1
+    when "--plastic-home" then opts[:plastic_home] = next_value!(argv, i, arg); i += 1
+    else
+      usage_abort("unknown flag #{arg.inspect}")
+    end
+    i += 1
+  end
+  opts
+end
+
+def expand(path)
+  File.expand_path(path.to_s.sub(/\A~/, Dir.home))
+end
+
+# Sibling of this script's dir, matching append-ledger's own resolution:
+# in-repo (<repo>/scripts/session-commit -> <repo>/templates) and installed
+# (~/.plastic/scripts/session-commit -> ~/.plastic/templates).
+def default_templates_dir
+  File.expand_path("../templates", __dir__)
+end
+
+# The fail-open guarantee (spec D1: exit 0 always, except a usage error)
+# must survive a store or ledger failure too (review R2), not only a git
+# failure: a read-only store, a damaged install missing templates/, or any
+# other write failure used to sit outside every rescue, so the CLI could
+# exit 1 with a raw Ruby backtrace on stderr and zero savepoint lines, even
+# after the git commit itself had already landed. `main`'s own body is
+# wrapped so nothing here can turn into a crash; the ledger write is a
+# second, inner rescue so a lost savepoint line never also swallows the
+# result the caller already needs on stdout.
+def main(argv)
+  opts = parse_args(argv)
+  usage_abort("--cwd is required") if opts[:cwd].nil?
+  usage_abort("--summary is required") if opts[:summary].nil?
+
+  plastic_home = expand(opts[:plastic_home] || ENV.fetch("PLASTIC_HOME", "~/.plastic"))
+  store = opts[:store] ? expand(opts[:store]) : File.join(plastic_home, "store")
+  cwd = expand(opts[:cwd])
+
+  day = opts[:day] || SessionLedger.day_id
+  session = SessionLedger.short_session_id(opts[:session], ENV["CLAUDE_CODE_SESSION_ID"])
+  project = SessionLedger.project_slug(cwd, plastic_home: plastic_home)
+
+  begin
+    templates = default_templates_dir
+    SessionLedger.open_day(store: store, day: day, templates: templates, author: session) if Dir.exist?(templates)
+  rescue StandardError => e
+    warn "session-commit: could not open the day ledger: #{e.message}"
+  end
+
+  result = SessionGit.commit!(cwd: cwd, summary: opts[:summary], day: day, session: session,
+                               plastic_home: plastic_home, store: store)
+
+  begin
+    # Does not depend on open_day having run: a damaged install with no
+    # templates/, or a store error above, must not also block the append.
+    savepoint_path = SessionLedger.savepoint_path(store, day)
+    FileUtils.mkdir_p(File.dirname(savepoint_path))
+    line = SessionLedger.savepoint_line(result.event, session, project, result.message, now: Time.now)
+    SessionLedger.append_line(savepoint_path, line, header: nil)
+  rescue StandardError => e
+    warn "session-commit: could not write the savepoint line: #{e.message}"
+  end
+
+  puts result.message
+  exit 0
+rescue StandardError => e
+  warn "session-commit: #{e.message}"
+  exit 0
+end
+
+main(ARGV) if $PROGRAM_NAME == __FILE__

package/scripts/spawn-preamble

@@ -22,8 +22,9 @@
 #
 # Exit codes: 0 (preamble emitted), 2 (usage).
 
-require_relative "lib/bridge"
+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.
@@ -56,7 +57,7 @@ REPORT_CONTRACT =
   "insights field carrying 0..N durable nuggets (what I discovered worth keeping, " \
   "the most interesting residue of this turn; none if there were none); plus a " \
   "role-specific payload that fulfils your place in the What, Why, How, Exec cycle " \
-  "(for example the planner explains the plan back to the orchestrator). Populate " \
+  "(for example the executor reports what was built and the test result). Populate " \
   "the insights field even when you cannot write the intent file yourself: a " \
   "background or dispatched agent carries each nugget home in the report and the " \
   "orchestrator persists it via scripts/insight-append, so an insight never " \
@@ -90,7 +91,7 @@ end
 # id/intent we report match what the rest of Plastic sees. Returns a Hash (possibly
 # empty) — never raises.
 def frontmatter_for(intent_dir)
-  ifile = Bridge.intent_file(intent_dir)
+  ifile = Savepoint.intent_file(intent_dir)
   return {} unless File.exist?(ifile)
 
   content = File.read(ifile)
@@ -115,13 +116,19 @@ 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, Bridge::SAVEPOINT_FILE)
+  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(Bridge.derive_stage(intent_dir), Bridge.derive_stage(intent_dir))
+  STAGE_LABELS.fetch(Savepoint.derive_stage(intent_dir), Savepoint.derive_stage(intent_dir))
 end
 
 intent_dir_arg, role, step = parse_args(ARGV)

package/scripts/update.rb

@@ -3,7 +3,7 @@
 # frozen_string_literal: true
 
 # Plastic — `update` verb. Runs via `npx @zalom/plastic update` (bin/plastic.js) or directly.
-# Usage: ruby scripts/update.rb [--beta|--latest|--alpha] [--claude|--codex|--hermes|--all] [--help]
+# Usage: ruby scripts/update.rb [--beta|--latest|--alpha] [--yes] [--claude|--codex|--hermes|--all] [--help]
 #
 # Forward-only version transitions, sourced from npm dist-tags:
 #   - no flag                = next version on the CURRENT channel (derived from VERSION)
@@ -62,7 +62,7 @@ class Update < InstallerCore
       warn "No published version on the #{requested} channel."
       return 1
     when :ok
-      if res[:kind] == :cross_bleeding && !confirm_bleeding(iv, res[:target])
+      if res[:kind] == :cross_bleeding && !confirm_bleeding(iv, res[:target], argv)
         puts "Aborted."
         return 1
       end
@@ -222,7 +222,10 @@ class Update < InstallerCore
     nil
   end
 
-  def confirm_bleeding(current, target)
+  # --yes (intent 310) answers the bleeding-edge question without a tty, so a script or an
+  # agent can run `update --alpha --yes`; without it a non-tty run aborts as before.
+  def confirm_bleeding(current, target, argv = [])
+    return true if argv.include?("--yes")
     return false unless $stdin.tty?
     print "Switch from #{current} to the less-stable #{target}? [y/N]: "
     ($stdin.gets&.strip || "").downcase.start_with?("y")
@@ -248,6 +251,7 @@ class Update < InstallerCore
         --latest      Switch to / advance the stable channel
         --beta        Switch to / advance the beta channel
         --alpha       Switch to / advance the alpha channel (bleeding edge — confirmed)
+        --yes         Confirm a switch toward bleeding edge without a prompt (scripts, agents)
 
       Agent options (default: --claude):
         --claude --codex --hermes --all

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/agent-advisor/SKILL.md

@@ -33,7 +33,7 @@ when the ordering decides where you spend the next day.
 Never buy a consultation for: anything a tool can answer (search, reading code, running
 tests, documentation), writing code at volume, confirming a decision you already made,
 style or naming a linter would settle, or anything reversible and cheap you have not
-tried first. The full buy/never-buy list, the tier table, and the entry test live in
+tried first. The full buy/never-buy list, the effort table, and the entry test live in
 `references/advisor-protocol.md`; read it before writing a brief for the first time in
 a session.
 
@@ -50,7 +50,7 @@ a session.
    advisor is disabled and point at "Setting the default" below.
 4. Dispatch the resolved agent with a brief built per `references/advisor-protocol.md`
    section 4 (natural prose, the block is a completeness check, not a form to fill).
-   State TIER (S, M, or L) and EFFORT explicitly; classify low and prove your way up,
+   State EFFORT and the answer shape explicitly; classify low and prove your way up,
    never open high "to be safe".
 5. Consume the answer per the protocol's section 5: run the Operating Manual's
    five-question self-test on the advisor's plan before executing it. Advice is input,
@@ -86,7 +86,7 @@ the new default back to the user in one line.
 ## References
 
 - `references/advisor-protocol.md`: the full shipped Advisor Protocol (what to buy,
-  tiers and effort, the entry test, how to write a brief that earns its cost, the
+  effort and answer shape, the entry test, how to write a brief that earns its cost, the
   answer contract, session economics, anti-patterns). Read it before the first
   consultation in a session; the second consultation in the same advisor thread costs a
   fraction of the first, so keep follow-ups on one thread rather than opening a new one.