@zalom/plastic 2.0.0-alpha.25 → 2.0.0-alpha.27

package/scripts/lib/installer_core.rb

@@ -1132,7 +1132,12 @@ class InstallerCore
     # Codex-scoped overrides only (agents.models.codex.*): a literal Claude
     # model id set under agents.models.claude.* (or the legacy flat form,
     # which resolves as claude) must never reach a Codex TOML.
-    installed += generate_codex_agents(File.join(config[:home_dir], "agents"), models: agent_model_overrides(harness: "codex"))
+    installed += generate_codex_agents(
+      File.join(config[:home_dir], "agents"),
+      models: agent_model_overrides(harness: "codex"),
+      efforts: agent_effort_overrides(harness: "codex"),
+      advisor_enabled: advisor_enabled?
+    )
 
     # Instruction injection (L1): Plastic standing conventions into ~/.codex/AGENTS.md.
     # Partial-ownership file, so it is NOT manifest-tracked (stripped surgically on uninstall).
@@ -1162,24 +1167,17 @@ class InstallerCore
   # a whole-file, Plastic-owned .toml per repo agents/*.md instead of copying markdown.
   # The returned paths append to `installed`, so they are manifest-tracked and pruned on
   # uninstall by the manifest whole-file-delete path, exactly like ~/.claude/agents/*.md.
-  def generate_codex_agents(agents_root, models: {})
+  def generate_codex_agents(agents_root, models: {}, efforts: {}, advisor_enabled: true)
     sources = Dir.glob(File.join(package_root, "agents", "*.md"))
     return [] if sources.empty?
 
     FileUtils.mkdir_p(agents_root)
     sources.filter_map do |src|
       basename = File.basename(src, ".md")
-      # Codex advisor support is out of scope for this release (intent 185): the
-      # owner has not evaluated the Codex reasoning-model ecosystem long enough to
-      # judge it. Skip every AgentModels::CONSULTATION_AGENTS file (both
-      # plastic-advisor and plastic-faux-advisor) by name, a deliberate and
-      # mechanical scope cut tracked at intent 186 (Codex advisor evaluation), not
-      # a permanent exclusion and not conditioned on any frontmatter or override
-      # value.
-      next if AgentModels::CONSULTATION_AGENTS.include?(basename)
+      next if !advisor_enabled && AgentModels::CONSULTATION_AGENTS.include?(basename)
 
       dest = File.join(agents_root, "#{basename}.toml")
-      write_text_atomic(dest, render_codex_agent_toml(src, models[basename]))
+      write_text_atomic(dest, render_codex_agent_toml(src, models[basename], efforts[basename]))
       dest
     end
   end
@@ -1187,16 +1185,25 @@ class InstallerCore
   # Render one repo agents/*.md into a deterministic Codex agent TOML document. Fixed field
   # order (name, description, the model field(s) from codex_model_fields, developer_instructions)
   # so regenerate is byte-identical (idempotency).
-  def render_codex_agent_toml(source_path, override)
+  def render_codex_agent_toml(source_path, override, effort_override = nil)
     front, body = split_frontmatter(File.read(source_path))
     name = (front["name"] || File.basename(source_path, ".md")).to_s
     description = (front["description"] || "").to_s
-    effective = (override && !override.to_s.empty? ? override : front["model"]).to_s
+    effective = if override && !override.to_s.empty?
+                  override
+                else
+                  AgentModels.shipped_model_for(name, harness: "codex") || front["model"]
+                end
+    effort = if effort_override && !effort_override.to_s.empty?
+               effort_override
+             else
+               front["effort"] || AgentModels.shipped_effort_for(name)
+             end
 
     parts = []
     parts << %(name = "#{toml_inline_escape(name)}")
     parts << %(description = "#{toml_inline_escape(description)}")
-    parts << codex_model_fields(effective)
+    parts << codex_model_fields(effective, effort: effort)
     parts << "developer_instructions = \"\"\"\n#{toml_ml_escape(body.strip)}\n\"\"\""
     parts.reject(&:empty?).join("\n") + "\n"
   end
@@ -1216,20 +1223,20 @@ class InstallerCore
   # The model-selection line(s). A known tier alias (opus/sonnet/haiku) emits BOTH a `model` line
   # (from AgentModels.codex_model_for, the intent-186 per-role Codex identity) and a
   # model_reasoning_effort line, model first for deterministic byte-identical regenerate. Any other
-  # non-empty value is a literal Codex model id emitted verbatim as `model` only. Empty -> no line
-  # (the agent inherits the session default). If an alias somehow lacks a mapped model, the effort
-  # line still emits alone (backward-safe).
-  def codex_model_fields(effective)
+  # non-empty value is a literal Codex model id. Every non-empty model also emits the resolved effort,
+  # medium by default or the harness-scoped override. Empty emits no model fields.
+  def codex_model_fields(effective, effort: AgentModels::DEFAULT_EFFORT)
     return "" if effective.nil? || effective.to_s.empty?
-    effort = AgentModels.effort_for(effective)
-    if effort
+    if AgentModels.effort_for(effective)
       lines = []
       model = AgentModels.codex_model_for(effective)
       lines << %(model = "#{toml_inline_escape(model)}") if model && !model.to_s.empty?
-      lines << %(model_reasoning_effort = "#{effort}")
+      lines << %(model_reasoning_effort = "#{toml_inline_escape(effort)}") unless effort.to_s.empty?
       lines.join("\n")
     else
-      %(model = "#{toml_inline_escape(effective.to_s)}")
+      lines = [%(model = "#{toml_inline_escape(effective.to_s)}")]
+      lines << %(model_reasoning_effort = "#{toml_inline_escape(effort)}") unless effort.to_s.empty?
+      lines.join("\n")
     end
   end
 
@@ -1362,8 +1369,7 @@ class InstallerCore
   # them to `installed` before write_manifest (manifest + prune are then automatic).
   # No-op safe: returns [] when the package has no agents dir or it is empty.
   # advisor_enabled: false (advisor.enabled config key) skips every
-  # AgentModels::CONSULTATION_AGENTS file entirely (both plastic-advisor and
-  # plastic-faux-advisor), so a user who declined the advisor never gets either
+  # AgentModels::CONSULTATION_AGENTS file entirely, so a user who declined the advisor never gets either
   # agent installed.
   def install_agents(agents_root, models: {}, efforts: {}, advisor_enabled: true)
     sources = Dir.glob(File.join(package_root, "agents", "*.md"))
@@ -1408,18 +1414,21 @@ class InstallerCore
   # ("claude" or "codex"). Defaults are NOT included, so unconfigured agents
   # keep their shipped frontmatter.
   #
-  # Both advisor agents (plastic-advisor, plastic-faux-advisor) resolve through
+  # Both advisor agents resolve through
   # this SAME generic map, like any other agent: a config author sets
-  # agents.models.claude.plastic-advisor (or the legacy flat
-  # agents.models.plastic-advisor, read as claude) to point either agent at a
+  # agents.models.claude.<agent> (or the legacy flat form, read as Claude) to point either agent at a
   # different literal model. There is no separate advisor-specific model key;
   # which agent the advisor SKILL routes to by default is a routing decision
   # (advisor.claude.default), never a model-selection one.
   def agent_model_overrides(project_dir = nil, harness: "claude")
-    global_config = load_config_yaml(File.join(plastic_home, "config.yml"))
+    global_path = File.join(plastic_home, "config.yml")
+    migrate_advisor_config_file(global_path)
+    global_config = load_config_yaml(global_path)
     project_config =
       if project_dir
-        load_config_yaml(File.join(project_dir, ".plastic_store", "config.yml"))
+        project_path = File.join(project_dir, ".plastic_store", "config.yml")
+        migrate_advisor_config_file(project_path)
+        load_config_yaml(project_path)
       else
         {}
       end
@@ -1427,8 +1436,12 @@ class InstallerCore
   end
 
   def agent_effort_overrides(project_dir = nil, harness: "claude")
-    global_config = load_config_yaml(File.join(plastic_home, "config.yml"))
-    project_config = project_dir ? load_config_yaml(File.join(project_dir, ".plastic_store", "config.yml")) : {}
+    global_path = File.join(plastic_home, "config.yml")
+    migrate_advisor_config_file(global_path)
+    global_config = load_config_yaml(global_path)
+    project_path = project_dir && File.join(project_dir, ".plastic_store", "config.yml")
+    migrate_advisor_config_file(project_path) if project_path
+    project_config = project_path ? load_config_yaml(project_path) : {}
     AgentModels.effort_override_map(project_config: project_config, global_config: global_config, harness: harness)
   end
 
@@ -1443,10 +1456,14 @@ class InstallerCore
     value != false
   end
 
-  # Agent-name shorthands for the --advisor flag: the two shipped choices,
-  # named for the role (real advisor vs. the cheaper imitation), never a model
-  # name.
-  ADVISOR_SHORTHANDS = { "real" => "plastic-advisor", "faux" => "plastic-faux-advisor" }.freeze
+  ADVISOR_NAME_MIGRATIONS = {
+    "plastic-advisor" => "plastic-primary-advisor",
+    "plastic-faux-advisor" => "plastic-secondary-advisor"
+  }.freeze
+  ADVISOR_SHORTHANDS = {
+    "primary" => "plastic-primary-advisor", "secondary" => "plastic-secondary-advisor",
+    "real" => "plastic-primary-advisor", "faux" => "plastic-secondary-advisor"
+  }.freeze
 
   # Write advisor.enabled / advisor.claude.default into the global config.yml
   # from install-time flags. Absent flags change nothing: advisor.enabled
@@ -1454,7 +1471,7 @@ class InstallerCore
   # (the skill's own fallback chain applies) when missing.
   #   --no-advisor      -> advisor.enabled: false
   #   --advisor VALUE   -> advisor.claude.default: VALUE (an agent name, or the
-  #                        shorthand "real"/"faux")
+  #                        shorthand "primary"/"secondary")
   def apply_config_flags(argv)
     no_advisor = argv.include?("--no-advisor")
     advisor_idx = argv.index("--advisor")
@@ -1462,7 +1479,13 @@ class InstallerCore
     return unless no_advisor || advisor_value
 
     config_path = File.join(plastic_home, "config.yml")
-    config = load_config_yaml(config_path)
+    config = if File.exist?(config_path)
+               parsed = YAML.safe_load(File.read(config_path))
+               return false unless parsed.nil? || parsed.is_a?(Hash)
+               migrate_advisor_config(parsed || {})
+             else
+               {}
+             end
 
     if no_advisor
       config["advisor"] ||= {}
@@ -1477,6 +1500,9 @@ class InstallerCore
 
     FileUtils.mkdir_p(plastic_home)
     File.write(config_path, YAML.dump(config))
+    true
+  rescue StandardError
+    false
   end
 
   def load_config_yaml(path)
@@ -1486,6 +1512,45 @@ class InstallerCore
     {}
   end
 
+  # Renames retired advisor keys without discarding a current key. It accepts
+  # malformed config sections and leaves unrelated values untouched.
+  def migrate_advisor_config(config)
+    return {} unless config.is_a?(Hash)
+    config = Marshal.load(Marshal.dump(config))
+    advisor = config["advisor"]
+    if advisor.is_a?(Hash) && advisor["claude"].is_a?(Hash)
+      default = advisor["claude"]["default"]
+      advisor["claude"]["default"] = ADVISOR_NAME_MIGRATIONS.fetch(default, default)
+    end
+    agents = config["agents"]
+    %w[models efforts].each do |section_name|
+      section = agents.is_a?(Hash) ? agents[section_name] : nil
+      next unless section.is_a?(Hash)
+      migrate_advisor_keys!(section)
+      %w[claude codex].each { |harness| migrate_advisor_keys!(section[harness]) if section[harness].is_a?(Hash) }
+    end
+    config
+  end
+
+  def migrate_advisor_config_file(path)
+    return false unless path && File.file?(path)
+    parsed = YAML.safe_load(File.read(path))
+    return false unless parsed.is_a?(Hash)
+    migrated = migrate_advisor_config(parsed)
+    return false if migrated == parsed
+    File.write(path, YAML.dump(migrated))
+    true
+  rescue StandardError
+    false
+  end
+
+  def migrate_advisor_keys!(section)
+    ADVISOR_NAME_MIGRATIONS.each do |legacy, current|
+      section[current] = section[legacy] if !section.key?(current) && section.key?(legacy)
+      section.delete(legacy)
+    end
+  end
+
   # --- Legacy plugin migration ---
 
   # Earlier versions registered Plastic as a local marketplace plugin

package/scripts/lib/node_file.rb

@@ -5,7 +5,8 @@ require "yaml"
 require "date"
 
 # NodeFile (intent 334, n3): one node file's YAML envelope (`node`, `kind`,
-# `files`, `budget`) over a Markdown body, plus the deterministic id minter
+# `files`, `budget`, and the optional research `report`) over a Markdown body,
+# plus the deterministic id minter
 # (327 D1r, D5r, D9r-D12r, D16r). The kind-prefix rule lives here, not in
 # GraphEdges, which stays loose about id grammar so a numeric roadmap id
 # parses the same way (D12r).
@@ -83,6 +84,8 @@ module NodeFile
 
     budget, budget_errors = normalize_budget(fm["budget"])
     errors.concat(budget_errors)
+    report, report_errors = normalize_report(fm["report"], kind)
+    errors.concat(report_errors)
 
     {
       ok: errors.empty?,
@@ -90,15 +93,32 @@ module NodeFile
       kind: kind.empty? ? nil : kind,
       files: files.is_a?(Array) ? files : nil,
       budget: budget,
+      report: report,
       body: body,
       errors: errors,
     }
   end
 
   def failure(errors)
-    { ok: false, node: nil, kind: nil, files: nil, budget: nil, body: nil, errors: errors }
+    { ok: false, node: nil, kind: nil, files: nil, budget: nil, report: nil, body: nil, errors: errors }
   end
 
+  def normalize_report(raw, kind)
+    return [nil, []] if raw.nil?
+    return [nil, ["report: is allowed only on research nodes"]] unless kind == "research"
+    return [nil, ["report: must be a non-empty relative Markdown path under resources/"]] unless raw.is_a?(String)
+
+    path = raw
+    parts = path.split("/", -1)
+    valid = path == path.strip && parts.length >= 2 && parts.first == "resources" &&
+            parts.none? { |part| part.empty? || %w[. ..].include?(part) } &&
+            !path.include?("\\") && path.end_with?(".md")
+    return [nil, ["report: must be a relative .md path under resources/ with no traversal"]] unless valid
+
+    [path, []]
+  end
+  private_class_method :normalize_report
+
   # <id>.md or <id>--<slug>.md, exactly - a longer id's file (n11--x.md) must
   # never satisfy a shorter id (n1), so the id is matched as the whole prefix
   # up to end-of-string or the literal "--" separator, never as a substring

package/scripts/lib/node_input.rb

@@ -118,22 +118,26 @@ module NodeInput
     end
 
     text = render_node_block(node: node, kind: parsed[:kind], files: parsed[:files], budget: parsed[:budget],
-                              body: parsed[:body])
+                              report: parsed[:report], body: parsed[:body])
     { ok: true, error_kind: nil, text: text, errors: [], kind: parsed[:kind], files: parsed[:files] || [],
-      budget: parsed[:budget] }
+      budget: parsed[:budget], report: parsed[:report] }
   end
 
   def failure_block(kind, errors)
-    { ok: false, error_kind: kind, text: nil, errors: errors, kind: nil, files: nil, budget: nil }
+    { ok: false, error_kind: kind, text: nil, errors: errors, kind: nil, files: nil, budget: nil, report: nil }
   end
   private_class_method :failure_block
 
-  def render_node_block(node:, kind:, files:, budget:, body:)
+  def render_node_block(node:, kind:, files:, budget:, body:, report: nil)
     lines = []
     lines << "# Node #{node}"
     lines << "kind: #{kind}"
     lines << "files: #{Array(files).join(', ')}"
     lines << "budget: #{budget}"
+    if report
+      lines << "report: #{report}"
+      lines << "report delivery: return the complete Markdown body in the YAML report field; the runner writes it"
+    end
     lines << ""
     lines << body.to_s.strip
     "#{lines.join("\n")}\n"

package/scripts/lib/node_return.rb

@@ -33,7 +33,7 @@ module NodeReturn
   STATUSES = %w[done failed_verification needs_decision blocked].freeze
 
   ALLOWED_KEYS = %w[
-    node status commit summary findings proposed_nodes proposed_edges question reason
+    node status commit summary findings report proposed_nodes proposed_edges question reason
   ].freeze
 
   REQUIRED_FIELDS = {
@@ -51,7 +51,7 @@ module NodeReturn
 
   Result = Struct.new(
     :ok, :node, :status, :commit, :summary, :findings, :proposed_nodes, :proposed_edges,
-    :question, :reason, :errors,
+    :report, :question, :reason, :errors,
     keyword_init: true
   )
 
@@ -86,6 +86,10 @@ module NodeReturn
     proposed_edges, edge_errors = normalize_proposed_edges(doc["proposed_edges"])
     return failure(edge_errors) if edge_errors.any?
 
+    if !doc["report"].nil? && !doc["report"].is_a?(String)
+      return failure(["report: must be a Markdown string"])
+    end
+
     Result.new(
       ok: true,
       node: doc["node"].to_s,
@@ -95,6 +99,7 @@ module NodeReturn
       findings: normalize_findings(doc["findings"]),
       proposed_nodes: proposed_nodes,
       proposed_edges: proposed_edges,
+      report: doc["report"],
       question: doc["question"],
       reason: doc["reason"],
       errors: [],
@@ -111,7 +116,7 @@ module NodeReturn
   def failure(errors)
     Result.new(
       ok: false, node: nil, status: nil, commit: nil, summary: nil, findings: [],
-      proposed_nodes: [], proposed_edges: [], question: nil, reason: nil,
+      proposed_nodes: [], proposed_edges: [], report: nil, question: nil, reason: nil,
       errors: Array(errors)
     )
   end

package/scripts/lib/runner_absorb.rb

@@ -100,6 +100,7 @@ module RunnerAbsorb
     node_decl = ((context.graph || {})[:nodes] || {})[node] || {}
     kind = node_decl[:kind]
     declared_files = normalize_files(node_decl[:files])
+    report_path = declared_report_path(intent_dir, node)
 
     # v2 NEW-2: a `graph.md` that failed to parse, or a node whose kind
     # cannot be resolved from it, refuses right here - before ANY check
@@ -143,6 +144,11 @@ module RunnerAbsorb
       return fail_check(savepoint_path, context, node, "node_mismatch", checks_ran, holder, extra_fields, now, ledger)
     end
 
+    report_reason = report_contract_violation(kind, report_path, parsed)
+    if report_reason
+      return fail_check(savepoint_path, context, node, report_reason, checks_ran, holder, extra_fields, now, ledger)
+    end
+
     append_findings(intent_dir, node, parsed.findings, now: now)
 
     proposal_result = nil
@@ -267,6 +273,14 @@ module RunnerAbsorb
     end
 
     commit_value = merge_commit || parsed.commit
+    if report_path
+      report_result = persist_report(intent_dir, report_path, parsed.report)
+      unless report_result[:ok]
+        return finish.call(fail_check(savepoint_path, context, node, report_result[:reason], gates.split("+") + ["report"],
+                                      holder, extra_fields, now, ledger))
+      end
+      gates = "#{gates}+report"
+    end
     fields = { gates: gates, commit: commit_value, holder: holder, suite: suite_value }.merge(extra_fields)
     result = write_transition(savepoint_path, context, node, "done", fields, now: now, ledger: ledger)
 
@@ -420,6 +434,48 @@ module RunnerAbsorb
   end
   private_class_method :normalize_scope_path
 
+  # --- research report -------------------------------------------------------
+
+  def declared_report_path(intent_dir, node)
+    path = ReadySet.find_node_path(intent_dir, node)
+    return nil unless path
+
+    parsed = NodeFile.parse(path)
+    parsed[:ok] ? parsed[:report] : nil
+  end
+  private_class_method :declared_report_path
+
+  def report_contract_violation(kind, declared, parsed)
+    return "report_not_declared" if parsed.report && declared.nil?
+    return nil unless parsed.status == "done"
+    return "report_missing" if declared && parsed.report.to_s.strip.empty?
+    return "report_not_research" if parsed.report && kind.to_s != "research"
+
+    nil
+  end
+  private_class_method :report_contract_violation
+
+  def persist_report(intent_dir, relative_path, content)
+    resources_root = File.expand_path(File.join(intent_dir, "resources"))
+    target = File.expand_path(File.join(intent_dir, relative_path.to_s))
+    unless target.start_with?("#{resources_root}/") && target.end_with?(".md")
+      return { ok: false, reason: "report_path_invalid" }
+    end
+
+    if File.exist?(target)
+      return { ok: true, path: target } if File.binread(target) == content.to_s
+
+      return { ok: false, reason: "report_conflict" }
+    end
+
+    FileUtils.mkdir_p(File.dirname(target))
+    AtomicWrite.write(target, content.to_s)
+    { ok: true, path: target }
+  rescue StandardError
+    { ok: false, reason: "report_write_failed" }
+  end
+  private_class_method :persist_report
+
   # --- named tests -----------------------------------------------------------
 
   # Row 4.19/minor 1: read the node's own failure-mode matrix table, take

package/scripts/lib/runner_dispatch.rb

@@ -37,7 +37,7 @@ module RunnerDispatch
   RETURN_CONTRACT = <<~TEXT.freeze
     RETURN CONTRACT: reply with exactly one YAML document as your final
     message, nothing else around it. Keys: node, status, commit, summary,
-    findings, proposed_nodes, proposed_edges, question, reason. status is one
+    findings, report, proposed_nodes, proposed_edges, question, reason. status is one
     of done, failed_verification, needs_decision, blocked. done requires
     commit; needs_decision requires question; failed_verification and
     blocked require reason. Anything that does not parse under this closed
@@ -47,7 +47,7 @@ module RunnerDispatch
   HARD_CAP_RE = /\Ais at its dispatch cap \((\d+)\/(\d+)\)\z/.freeze
 
   # D8 (355, n6): the agent every dispatched, non-decision node names - a
-  # role, never a harness (matrix 6.5), and never `plastic-advisor`, which
+  # role, never a harness (matrix 6.5), and never a consultation advisor, which
   # stays a deliberate, never-auto-dispatched consultation agent.
   SPAWN_AGENT = "plastic-executor"
 
@@ -56,8 +56,8 @@ module RunnerDispatch
   # (NodeInput.test_command_block, n4), and the call cap (n2) - fenced so a
   # session pastes it straight into the Agent tool (327 D42: the runner
   # itself never spawns).
-  def spawn_block(model:, input:, test_command:, call_cap:, agent: SPAWN_AGENT)
-    lines = ["agent: #{agent}", "model: #{model}", "input: #{input}", test_command,
+  def spawn_block(model:, input:, test_command:, call_cap:, effort: AgentModels::DEFAULT_EFFORT, agent: SPAWN_AGENT)
+    lines = ["agent: #{agent}", "model: #{model}", "effort: #{effort}", "input: #{input}", test_command,
              NodeInput.call_cap_sentence(call_cap)]
     (["```"] + lines + ["```"]).join("\n")
   end
@@ -220,7 +220,8 @@ module RunnerDispatch
     savepoint_path = File.join(intent_dir.to_s, "savepoint.md")
 
     holder = context.session
-    model = RunnerPolicy.model_for(kind, config: config)
+    model = RunnerPolicy.model_for(kind, config: config, harness: harness)
+    effort = RunnerPolicy.effort_for(kind, config: config, harness: harness)
     expires = RunnerPolicy.lease_expires(kind, now: now)
     calls_cap = RunnerPolicy.call_cap(kind, config: config)
 
@@ -267,7 +268,7 @@ module RunnerDispatch
     # Row 1.19/1.20/D21: harness= rides alongside model= on every `running`
     # line, resolved once by the caller through HarnessAdapter and threaded
     # straight through here - never re-resolved, never a literal.
-    fields = { holder: holder, expires: expires, input: build_result[:sha], model: model, harness: harness,
+    fields = { holder: holder, expires: expires, input: build_result[:sha], model: model, effort: effort, harness: harness,
                calls: calls_cap }
 
     result = begin
@@ -287,11 +288,13 @@ module RunnerDispatch
     end
 
     test_command = NodeInput.test_command_block(intent_dir: intent_dir, files: (nodes_decl[node] || {})[:files])
-    spawn = spawn_block(model: model, input: build_result[:path], test_command: test_command, call_cap: calls_cap)
+    spawn = spawn_block(model: model, effort: effort, input: build_result[:path], test_command: test_command,
+                        call_cap: calls_cap)
 
     {
       ok: true,
-      entry: { node: node, kind: kind.to_s, role: role_for(kind), model: model, worktree: provisioned[:path],
+      entry: { node: node, kind: kind.to_s, role: role_for(kind), model: model, effort: effort,
+                worktree: provisioned[:path],
                 input: build_result[:path], spawn: spawn },
     }
   end
@@ -507,6 +510,7 @@ module RunnerDispatch
       "return_contract" => RETURN_CONTRACT,
       "dispatch" => dispatched.map do |d|
         { "node" => d[:node], "kind" => d[:kind], "role" => d[:role], "model" => d[:model],
+          "effort" => d[:effort],
           "worktree" => d[:worktree], "input" => d[:input] }
       end,
       "spawn" => dispatched.map { |d| d[:spawn] }

package/scripts/lib/runner_policy.rb

@@ -35,7 +35,7 @@ module RunnerPolicy
   # resolves through AgentModels::TIER_DEFAULTS, the one place
   # `plastic-executor`'s shipped tier is already declared (post-execution
   # review minor 4), rather than a second, independently-drifting literal
-  # here. `plastic-advisor` carries no lifecycle-stage entry in
+  # here. `plastic-primary-advisor` carries no lifecycle-stage entry in
   # TIER_DEFAULTS at all (it is a consultation agent, never auto-dispatched
   # - see agent_models.rb's own docstring), so its default stays the one
   # literal this table cannot source from anywhere else.
@@ -43,7 +43,7 @@ module RunnerPolicy
   DEFAULT_ADVISOR_MODEL = "opus"
 
   EXECUTOR_CONFIG_KEY = "plastic-executor"
-  ADVISOR_CONFIG_KEY = "plastic-advisor"
+  ADVISOR_CONFIG_KEY = "plastic-primary-advisor"
 
   # {model_role:, worktree:, retry_cap:, diff_rule:, lease_minutes:} per kind
   # (327 D12). `decision` carries no retry cap or lease: it is never
@@ -69,24 +69,42 @@ module RunnerPolicy
   # verify resolves the advisor model, and a config with no override falls
   # back to the shipped default rather than an empty string (`running`
   # requires a non-blank `model=`).
-  def model_for(kind, config: {})
-    policy_for(kind)[:model_role] == :advisor ? advisor_model(config: config) : executor_model(config: config)
+  def model_for(kind, config: {}, harness: "claude-code")
+    alias_or_id = policy_for(kind)[:model_role] == :advisor ? advisor_model(config: config, harness: harness) :
+                                                              executor_model(config: config, harness: harness)
+    codex_harness?(harness) ? (AgentModels.codex_model_for(alias_or_id) || alias_or_id) : alias_or_id
   end
 
-  def executor_model(config: {})
-    resolve_model(config, EXECUTOR_CONFIG_KEY, DEFAULT_EXECUTOR_MODEL)
+  def executor_model(config: {}, harness: "claude-code")
+    resolve_model(config, EXECUTOR_CONFIG_KEY, DEFAULT_EXECUTOR_MODEL, harness)
   end
 
-  def advisor_model(config: {})
-    resolve_model(config, ADVISOR_CONFIG_KEY, DEFAULT_ADVISOR_MODEL)
+  def advisor_model(config: {}, harness: "claude-code")
+    resolve_model(config, ADVISOR_CONFIG_KEY, DEFAULT_ADVISOR_MODEL, harness)
   end
 
-  def resolve_model(config, key, shipped_default)
-    value = AgentModels.models_section(config)[key]
+  def effort_for(kind, config: {}, harness: "claude-code")
+    key = policy_for(kind)[:model_role] == :advisor ? ADVISOR_CONFIG_KEY : EXECUTOR_CONFIG_KEY
+    value = AgentModels.efforts_section(config, harness_name(harness))[key]
+    present?(value) ? value : AgentModels::DEFAULT_EFFORT
+  end
+
+  def resolve_model(config, key, shipped_default, harness)
+    value = AgentModels.models_section(config, harness: harness_name(harness))[key]
     present?(value) ? value : shipped_default
   end
   private_class_method :resolve_model
 
+  def harness_name(harness)
+    codex_harness?(harness) ? "codex" : "claude"
+  end
+  private_class_method :harness_name
+
+  def codex_harness?(harness)
+    harness.to_s == "codex"
+  end
+  private_class_method :codex_harness?
+
   def present?(value)
     !(value.nil? || value.to_s.strip.empty?)
   end

package/scripts/node-run

@@ -201,7 +201,8 @@ module NodeRunCLI
     message_path = "#{out_path}.msg"
 
     timeout_seconds = timeout_flag ? timeout_flag.to_i : CodexAdapter.timeout_seconds(kind)
-    codex_argv = CodexAdapter.build_argv(kind: kind, worktree: worktree, output_last_message: message_path)
+    codex_argv = CodexAdapter.build_argv(kind: kind, worktree: worktree, output_last_message: message_path,
+                                          model: fields["model"], effort: fields["effort"])
 
     result = CodexAdapter.execute(codex_argv, stdin_data: input_bytes, timeout_seconds: timeout_seconds,
                                    output_last_message_path: message_path)