@zalom/plastic 2.0.0-alpha.26 → 2.0.0-alpha.28

package/scripts/lib/agent_models.rb

@@ -14,8 +14,7 @@ module AgentModels
   # HarnessAdapter::AGENT_TYPE_BY_KIND. work and research resolve the
   # executor tier, verify the advisor tier, mirroring RunnerPolicy's
   # model_role split (327 D12): work and research run on plastic-executor's
-  # own tier, verify on the same tier plastic-advisor's imitation
-  # (plastic-faux-advisor) ships, never the cheap tier.
+  # own tier, and verify on the lifecycle advisor tier, never the cheap tier.
   TIER_DEFAULTS = {
     "plastic-enforcer" => "opus",
     "plastic-executor" => "sonnet",
@@ -24,32 +23,35 @@ module AgentModels
     "plastic-node-research" => "sonnet"
   }.freeze
 
-  # The two advisor agents (intent 185 final design): plastic-advisor (the real
-  # advisor, ships `model: fable`) and plastic-faux-advisor (the imitation
-  # advisor, an ordinary model carrying the same reasoning discipline inline,
-  # ships `model: opus`). Both are shipped DEFAULTS in frontmatter, never a
+  # The two consultation agents are Primary Advisor and Secondary Advisor.
+  # Both ship Fable; Primary uses medium effort and Secondary uses high effort.
+  # Both are shipped defaults in frontmatter, never a
   # hard-wired identity: agents.models.claude.<name> (or the legacy flat form)
   # overrides either one through the same install-time frontmatter rewrite
   # every agent override uses. Neither is a lifecycle-stage role: never
-  # dispatched by the auto pipeline, not part of TIER_DEFAULTS. Claude-only for
-  # this release (generate_codex_agents skips both by name; the Codex advisor
-  # case is intent 186, not a permanent exclusion).
-  #
-  # Intent 186 DEFINES the advisor Codex pairing but keeps emission deferred: when the skip is
-  # lifted, plastic-advisor pairs to gpt-5.6-sol at xhigh (the deepest) and plastic-faux-advisor
-  # to gpt-5.6-terra at high (cheaper). Neither is in TIER_DEFAULTS and neither is auto-dispatched.
-  CONSULTATION_AGENTS = %w[plastic-advisor plastic-faux-advisor].freeze
-
-  # Codex reasoning-effort per tier alias (intent 102a). model_reasoning_effort is a
-  # depth-of-thinking dial independent of model selection (181 line 317-318), so mapping
-  # the tier here never encodes a rotting Codex model id (116 D1). opus is the deepest
-  # reasoning tier -> the deepest generally-safe effort (high, not the model-dependent
-  # xhigh); sonnet the mid execution tier -> medium; haiku the lightest -> low. minimal is
-  # unused.
+  # dispatched by the auto pipeline, not part of TIER_DEFAULTS. Codex installs
+  # generate both advisors with Astra and preserve each role's effort.
+  CONSULTATION_AGENTS = %w[plastic-primary-advisor plastic-secondary-advisor].freeze
+
+  SHIPPED_MODEL_DEFAULTS = TIER_DEFAULTS.merge(
+    "plastic-primary-advisor" => "fable",
+    "plastic-secondary-advisor" => "fable"
+  ).freeze
+
+  # Codex reasoning effort per tier alias. Model choice and reasoning effort are independent:
+  # aliases select the recommended OpenAI model, while every Plastic role starts at medium.
+  # A valid harness-scoped user override can still choose another effort for one agent.
   EFFORT_BY_ALIAS = {
-    "opus" => "high",
+    "opus" => "medium",
     "sonnet" => "medium",
-    "haiku" => "low"
+    "haiku" => "medium"
+  }.freeze
+
+  DEFAULT_EFFORT = "medium"
+
+  SHIPPED_EFFORT_DEFAULTS = {
+    "plastic-primary-advisor" => "medium",
+    "plastic-secondary-advisor" => "high"
   }.freeze
 
   # Codex model id per tier alias (intent 186). Codex has NO vendor alias layer: every model id
@@ -58,17 +60,26 @@ module AgentModels
   # centralizing every id in ONE map: Plastic owns the alias, so per-role identity costs a single
   # line to refresh on a Codex deprecation plus a Plastic release, and no per-role file carries a
   # raw id. opus (deepest reasoning tier) -> the flagship Sol; sonnet (execution tier) -> the
-  # balanced Terra; haiku (lightest) -> the fast/cheap Luna. Paired with EFFORT_BY_ALIAS so
-  # reasoning roles get a stronger model AND higher effort than executors. This is a shipped
-  # DEFAULT, fully overridable via agents.models.codex.<name>.
+  # balanced Terra; haiku (lightest) -> the fast/cheap Luna. This is a shipped
+  # DEFAULT, fully overridable via agents.models.codex.<name>. Model strength does not change
+  # effort: all three aliases use medium unless agents.efforts.codex.<name> overrides it.
   CODEX_MODEL_BY_ALIAS = {
     "opus" => "gpt-5.6-sol",
     "sonnet" => "gpt-5.6-terra",
     "haiku" => "gpt-5.6-luna"
   }.freeze
 
+  CODEX_MODEL_BY_AGENT = {
+    "plastic-primary-advisor" => "gpt-6-astra",
+    "plastic-secondary-advisor" => "gpt-6-astra"
+  }.freeze
+
   module_function
 
+  def shipped_effort_for(agent)
+    SHIPPED_EFFORT_DEFAULTS.fetch(agent.to_s, DEFAULT_EFFORT)
+  end
+
   # Pull { basename => model } out of a loaded config hash's `agents.models`
   # section, scoped to `harness` ("claude" or "codex"), tolerating a missing or
   # malformed shape. `agents.models` can mix two shapes: legacy FLAT scalar
@@ -124,4 +135,11 @@ module AgentModels
   def codex_model_for(value)
     CODEX_MODEL_BY_ALIAS[value.to_s]
   end
+
+  def shipped_model_for(agent, harness: "claude")
+    value = SHIPPED_MODEL_DEFAULTS[agent.to_s]
+    return value unless harness.to_s == "codex"
+
+    CODEX_MODEL_BY_AGENT[agent.to_s] || codex_model_for(value) || value
+  end
 end

package/scripts/lib/arm.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
+require_relative "store_layout"
 require "digest"
 require "fileutils"
 require_relative "lock"
@@ -63,7 +64,7 @@ module Arm
   end
 
   def global_store(home)
-    File.join(File.expand_path(home), ".plastic", "store")
+    Plastic::StoreLayout.global_store(File.join(File.expand_path(home), ".plastic"))
   end
 
   # The minimal hash Worktree.provision, release, and finish consume: the

package/scripts/lib/backup.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "digest"
+require "json"
+require "tmpdir"
+require "zlib"
+require_relative "store_sync"
+
+module Plastic
+  module Backup
+    DATABASES = [SearchIndex::NAME, WorkGraph::NAME, ReferenceArchive::NAME].freeze
+    ROOT_FILES = %w[config.yml projects.yml INDEX.md].freeze
+    Missing = Class.new(StandardError)
+
+    def self.dir(home)
+      File.join(home, "backups")
+    end
+
+    def self.list(home)
+      Dir.glob(File.join(dir(home), "plastic-backup--*.tar.gz")).sort
+    end
+
+    def self.call(home, version:, now: Time.now.utc)
+      missing = DATABASES.reject { |name| File.exist?(File.join(home, name)) }
+      raise Missing, missing.join(", ") unless missing.empty?
+
+      Dir.mktmpdir("plastic-backup") do |work|
+        DATABASES.each { |name| Sqlite.call(File.join(home, name), "VACUUM INTO #{Sqlite.quote(File.join(work, name))};", readonly: true) }
+        FileUtils.cp(ROOT_FILES.map { |name| File.join(home, name) }.select { |path| File.exist?(path) }, work)
+        File.write(File.join(work, "manifest.json"), JSON.pretty_generate(manifest(work, version, now)))
+        pack(work, File.join(dir(home), "plastic-backup--#{now.strftime("%Y%m%dT%H%M%SZ")}.tar.gz"))
+      end
+    end
+
+    def self.manifest(work, version, now)
+      files = Dir.children(work).sort.map do |name|
+        path = File.join(work, name)
+        {"name" => name, "bytes" => File.size(path), "sha256" => Digest::SHA256.file(path).hexdigest}
+      end
+      {"version" => version, "at" => now.strftime("%Y-%m-%dT%H:%M:%SZ"), "files" => files}
+    end
+
+    def self.pack(work, archive)
+      require "rubygems"
+      require "rubygems/package"
+      FileUtils.mkdir_p(File.dirname(archive))
+      draft = "#{archive}.tmp"
+      Zlib::GzipWriter.open(draft) do |gzip|
+        Gem::Package::TarWriter.new(gzip) do |tar|
+          Dir.children(work).sort.each do |name|
+            path = File.join(work, name)
+            tar.add_file_simple(name, 0o644, File.size(path)) { |entry| IO.copy_stream(path, entry) }
+          end
+        end
+      end
+      File.rename(draft, archive)
+      archive
+    ensure
+      FileUtils.rm_f(draft.to_s)
+    end
+  end
+end

package/scripts/lib/cli/command.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "optparse"
+require_relative "output"
+require_relative "scope"
+
+module Plastic
+  class CLI
+    class Command
+      OK = 0
+      FAILED = 1
+      USAGE = 2
+      REFUSED = 3
+
+      Usage = Class.new(StandardError)
+      Refusal = Class.new(StandardError)
+      Failure = Class.new(StandardError)
+
+      def self.call(...)
+        command = new(...)
+        command.call
+        command.flush
+        OK
+      rescue OptionParser::ParseError, Scope::UnknownProject, Usage => e
+        command.output.usage(e.message, self::USAGE_LINE)
+        USAGE
+      rescue Refusal => e
+        command.output.refused(e.message)
+        REFUSED
+      rescue Failure => e
+        command.output.failed(e.message)
+        FAILED
+      end
+
+      attr_reader :output
+
+      def initialize(argv, out:, err:, env: ENV, home: Dir.home, directory: Dir.pwd)
+        @argv = argv.dup
+        @env = env
+        @home = home
+        @directory = directory
+        @output = Output.new(out: out, err: err)
+      end
+
+      def call
+        raise NoMethodError, "#{self.class} must define call"
+      end
+
+      def flush
+        @output.flush(json: options[:json])
+      end
+
+      private
+
+      def options
+        return @options if @options
+
+        @options = {}
+        parser.parse!(@argv)
+        @options
+      end
+
+      def arguments
+        options
+        @argv
+      end
+
+      def parser
+        @parser ||= OptionParser.new do |o|
+          o.banner = self.class::USAGE_LINE
+          o.on("--json") { @options[:json] = true }
+          switches(o)
+        end
+      end
+
+      def switches(_parser)
+        nil
+      end
+
+      def scope
+        @scope ||= Scope.new(env: @env, home: @home, slug: options[:project], directory: @directory)
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/auto.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "subcommand_list"
+
+# `plastic auto` - the list of `plastic auto ...` subcommands, straight out of
+# the table.
+module Plastic
+  class CLI
+    module Commands
+      class Auto < SubcommandList
+        USAGE_LINE = "plastic auto SUBCOMMAND [options]"
+        PREFIX = "auto"
+        NEXT = "plastic auto take ID"
+        BECAUSE = "taking the intent is what every other auto subcommand needs first"
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/auto_brief.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "intent_command"
+
+# `plastic auto brief` - an intent's spawn preamble (`spawn-preamble`, run
+# through Legacy). `--role advisor` also prints the three shapes an advisor
+# request takes, so a dispatching lead never has to look them up.
+module Plastic
+  class CLI
+    module Commands
+      class AutoBrief < IntentCommand
+        USAGE_LINE = "plastic auto brief ID [--role ROLE] [--json]"
+
+        SCRIPT = "spawn-preamble"
+        AFTER = "plastic auto report ID"
+        BECAUSE = "the report closes the turn the preamble opened"
+
+        ADVISOR_SHAPES =
+          "State the shape you need: a verdict plus the biggest risk for one bounded " \
+          "decision; a stepped plan plus a risk map for a plan or plan review; rival " \
+          "approaches and kill criteria for architecture, one-way doors, or deadlocks."
+
+        def call
+          super
+          @output.row("advisor request shapes", ADVISOR_SHAPES) if role == "advisor"
+        end
+
+        private
+
+        def role
+          options[:role]
+        end
+
+        def switches(parser)
+          parser.on("--role ROLE") { |v| @options[:role] = v }
+        end
+
+        def script_arguments
+          role ? [intent_dir, "--role", role] : [intent_dir]
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/auto_lock.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../legacy"
+
+# `plastic auto lock` - inspects, repairs, or releases an intent's delivery
+# lock (`plastic-lock status|fix|release --intent-dir DIR`, run through
+# Legacy). The verb comes first, then the id, since the verb is what the
+# table's two-token match consumes as part of the command name.
+module Plastic
+  class CLI
+    module Commands
+      class AutoLock < Command
+        USAGE_LINE = "plastic auto lock status|fix|release ID [--json]"
+
+        VERBS = %w[status fix release].freeze
+        AFTER = {"status" => "plastic auto lock fix ID", "fix" => "plastic auto brief ID",
+                 "release" => "plastic session summary"}.freeze
+        BECAUSE = {"status" => "a stale or held lock is repaired by fix, not by re-arming",
+                   "fix" => "a repaired lock is ready for the preamble again",
+                   "release" => "the summary is what a freed lock leads to"}.freeze
+
+        def initialize(argv, runner: nil, **streams)
+          super(argv, **streams)
+          @runner = runner
+        end
+
+        def call
+          raise Usage, "VERB must be one of #{VERBS.join(", ")}" unless VERBS.include?(verb)
+
+          status = legacy.run("plastic-lock", verb, "--intent-dir", intent_dir)
+          raise Failure, "plastic-lock exited #{status}" unless status.zero?
+
+          @output.next_step(AFTER.fetch(verb).sub("ID", id.to_s), because: BECAUSE.fetch(verb))
+        end
+
+        private
+
+        def verb
+          arguments[0]
+        end
+
+        def id
+          arguments[1]
+        end
+
+        def intent_dir
+          dir = scope.intent_dir(id)
+          raise Failure, "no intent #{id.inspect} in #{scope.slug}; plastic status lists the ones that exist" unless dir
+
+          dir
+        end
+
+        def legacy
+          @legacy ||= Legacy.new(env: @env, runner: @runner)
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/auto_report.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative "intent_command"
+
+# `plastic auto report` - an intent's completion report (`agent-report`, run
+# through Legacy), then the review-by-risk rules a lead checks it against.
+module Plastic
+  class CLI
+    module Commands
+      class AutoReport < IntentCommand
+        USAGE_LINE = "plastic auto report ID [--role ROLE] [--json]"
+
+        SCRIPT = "agent-report"
+        AFTER = "plastic auto lock release ID"
+        BECAUSE = "closing the lock is what a delivered or abandoned report leads to"
+
+        REVIEW_RULES = <<~TEXT.chomp
+          Review by risk, boot 3, only when a rule fires; otherwise the green suite is
+          the review. Dispatch the post-execution reviewer when any of these holds:
+          1. the diff touches a path on the risk list (hooks, the lock, the arming
+             module, the installer, a release file).
+          2. a failure-mode matrix row names a test not in the diff, or a test the
+             green run did not execute.
+          3. the completion report carries a status other than delivered, or a
+             non-empty deviations or blockers field.
+          The reviewer returns a pass or fixes; at most one review-fix round, ever.
+        TEXT
+
+        def call
+          super
+          @output.row("review rules", REVIEW_RULES)
+        end
+
+        private
+
+        def role
+          options[:role]
+        end
+
+        def switches(parser)
+          parser.on("--role ROLE") { |v| @options[:role] = v }
+        end
+
+        def script_arguments
+          role ? [intent_dir, "--role", role] : [intent_dir]
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/auto_take.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "intent_command"
+
+# `plastic auto take` - arms the intent's delivery lock for this session
+# (`plastic-lock arm --intent-dir DIR --mode auto`, run through Legacy).
+module Plastic
+  class CLI
+    module Commands
+      class AutoTake < IntentCommand
+        USAGE_LINE = "plastic auto take ID [--json]"
+
+        SCRIPT = "plastic-lock"
+        AFTER = "plastic auto brief ID"
+        BECAUSE = "the preamble is the live state a taken intent is read from next"
+
+        private
+
+        def script_arguments
+          ["arm", "--intent-dir", intent_dir, "--mode", "auto"]
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/backup.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "version"
+require_relative "../../backup"
+
+module Plastic
+  class CLI
+    module Commands
+      class Backup < Command
+        USAGE_LINE = "plastic backup [--list] [--json]"
+
+        def call
+          options[:list] ? list : write
+        rescue Plastic::Backup::Missing => e
+          @output.next_step("plastic sync", because: "a backup copies the three databases, and sync builds them")
+          raise Failure, "no #{e.message} at #{scope.plastic_home}; run plastic sync"
+        rescue Sqlite::Error => e
+          raise Failure, e.message
+        end
+
+        private
+
+        def switches(parser)
+          parser.on("--list") { options[:list] = true }
+        end
+
+        def write
+          version = Version.new([], out: nil, err: nil, env: @env).found.last
+          @output.row("archive", Plastic::Backup.call(scope.plastic_home, version: version))
+          @output.next_step("plastic backup --list", because: "to restore, unpack the archive into an empty ~/.plastic and run plastic checkout")
+        end
+
+        def list
+          archives = Plastic::Backup.list(scope.plastic_home)
+          archives.each { |path| @output.row(File.basename(path), "#{File.size(path)} bytes  #{File.mtime(path).strftime("%Y-%m-%d %H:%M")}") }
+          @output.row("result", "no backup yet") if archives.empty?
+          @output.next_step("plastic backup", because: "copying backups/ off this machine is your choice; Plastic sends nothing")
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/checkout.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../../store_sync"
+
+module Plastic
+  class CLI
+    module Commands
+      class Checkout < Command
+        USAGE_LINE = "plastic checkout [--json]"
+
+        def call
+          home = scope.plastic_home
+          raise Failure, "no databases at #{home}; run plastic sync" unless File.exist?(ReferenceArchive.path(home))
+
+          restored = StoreSync.checkout(home)
+          @output.row("restored", restored.empty? ? "nothing was missing" : restored)
+          @output.next_step("plastic sync --dry-run", because: "checkout restores missing files only; a changed file is never overwritten")
+        rescue Sqlite::Error => e
+          raise Failure, e.message
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/continue.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../frontier"
+require_relative "../scope"
+
+# `plastic continue` - where one project stands and what runs next: the store it
+# uses, the intents it has open, its liveliest roadmap and that roadmap's
+# frontier, then the step to take and the rule behind it.
+#
+# With no roadmap the first active intent answers instead, so a project that
+# never grew a roadmap still gets a next step.
+module Plastic
+  class CLI
+    module Commands
+      class Continue < Command
+        USAGE_LINE = "plastic continue [--project SLUG] [--json]"
+
+        def call
+          @output.row("project", scope.slug)
+          @output.row("root", scope.root)
+          @output.row("active", active)
+          @output.row("roadmap", roadmap)
+          command, because = decision
+          @output.next_step(command, because: because)
+        rescue RoadmapSavepoint::MissingGroupingHeading => e
+          raise Failure, e.message
+        end
+
+        private
+
+        def switches(parser)
+          parser.on("--project SLUG") { |slug| @options[:project] = slug }
+        end
+
+        def active
+          scope.active_entries.map { |id, title| "#{id}  #{title}" }
+        end
+
+        def roadmap
+          return Frontier::NONE unless frontier.roadmap
+
+          "#{frontier.roadmap}  frontier #{frontier.heading}"
+        end
+
+        def decision
+          return [frontier.next_step, frontier.because] if frontier.id
+
+          id = scope.active_ids.first
+          return [plan_for(id), "#{id} is the first active intent in #{scope.slug}"] if id
+
+          ["plastic help", "#{scope.slug} has no active work and no roadmap"]
+        end
+
+        def plan_for(id)
+          dir = scope.intent_dir(id)
+          dir ? "read #{File.join(dir, "plan.md")}" : "plastic status"
+        end
+
+        def frontier
+          @frontier ||= Frontier.new(scope)
+        end
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/doctor.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "installer_verb"
+
+# `plastic doctor` - diagnoses Plastic installation health. The work is still
+# scripts/doctor.rb, run through Legacy; each finding prints its own repair.
+module Plastic
+  class CLI
+    module Commands
+      class Doctor < InstallerVerb
+        USAGE_LINE = "plastic doctor [--core] [--store WHICH]"
+        FLAGS = %w[--core --store].freeze
+
+        SCRIPT = "doctor.rb"
+        AFTER = "none"
+        BECAUSE = "the findings are the whole answer, and each one names its own repair"
+      end
+    end
+  end
+end

package/scripts/lib/cli/commands/feedback.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../command"
+require_relative "../legacy"
+
+# `plastic feedback "TITLE"` - files a report with feedback-report, the body
+# read from standard input and passed to the child process unchanged.
+module Plastic
+  class CLI
+    module Commands
+      class Feedback < Command
+        USAGE_LINE = 'plastic feedback "TITLE"'
+
+        def initialize(argv, runner: nil, **streams)
+          super(argv, **streams)
+          @runner = runner
+        end
+
+        def call
+          raise Usage, "plastic feedback needs a title" if title.nil? || title.strip.empty?
+
+          status = legacy.run("feedback-report", "--title", title)
+          raise Failure, "feedback-report exited #{status}" unless status.zero?
+
+          @output.next_step("none", because: "the report is saved as a draft; open the printed URL to send it")
+        end
+
+        private
+
+        def title
+          arguments.first
+        end
+
+        def legacy
+          @legacy ||= Legacy.new(env: @env, runner: @runner)
+        end
+      end
+    end
+  end
+end