@zalom/plastic 1.5.0 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalom/plastic",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "Intent-driven idea development system for AI coding agents",
   "type": "module",
   "bin": {

package/scripts/doctor.rb

@@ -14,6 +14,7 @@ require "yaml"
 require "time"
 require "date"
 require "digest"
+require "rubygems"
 
 require_relative "lib/qmd_sync"
 require_relative "lib/intent_validator"
@@ -71,13 +72,32 @@ class Doctor
     doctor.rb
   ].freeze
 
+  # The apply_patch PreToolUse veto only fires from Codex v0.123.0 onward
+  # (PR #18391, "emit hooks for apply_patch edits"). Below it the veto
+  # silently no-ops (intent 184).
+  CODEX_HOOKS_FLOOR = "0.123.0"
+
   attr_reader :plastic_home, :agents
 
+  # Testable shell-out default, mirroring QmdSync.default_runner: a real
+  # Open3.capture3 call in production, swappable for a fake in tests so no
+  # test needs a real codex binary or a PATH mutation.
+  def self.default_runner
+    lambda do |args|
+      require "open3"
+      out, _err, status = Open3.capture3("codex", *args)
+      [out, status.success?]
+    rescue Errno::ENOENT
+      ["", false] # codex not on PATH: undetectable, fail open
+    end
+  end
+
   def initialize(plastic_home: DEFAULT_PLASTIC_HOME, agents: DEFAULT_AGENTS,
-                  bookend_amnesty: LEGACY_BOOKEND_AMNESTY)
+                  bookend_amnesty: LEGACY_BOOKEND_AMNESTY, runner: Doctor.default_runner)
     @plastic_home = plastic_home
     @agents = agents
     @bookend_amnesty = bookend_amnesty
+    @runner = runner
   end
 
   # --- Flag parsing ---
@@ -1300,6 +1320,7 @@ class Doctor
     checks << codex_hooks_implemented_check(config)
     checks << codex_hook_trust_advisory_check if hooks_check[:status] == "pass"
     codex_config_toml_advisory_check(config).tap { |c| checks << c if c }
+    codex_version_floor_check(config).tap { |c| checks << c if c }
 
     checks
   end
@@ -1555,6 +1576,60 @@ class Doctor
     )
   end
 
+  # Codex version-floor advisory (intent 184): READ ONLY. The apply_patch PreToolUse
+  # veto (scripts/lib/hook_registry.rb, scripts/codex-hook) only fires from Codex
+  # v0.123.0 (PR #18391); below it the veto silently no-ops. version.json is Codex's
+  # update-checker cache and holds no installed version, so the only install-method-
+  # agnostic source is `codex --version`, shelled out through the injected runner.
+  # Four honest branches (intent 208, no pass-by-construction): absent home -> nil;
+  # present but undetectable -> distinct warn; below floor -> warn; at/above -> pass.
+  def codex_version_floor_check(config)
+    return nil unless File.exist?(config[:home_dir])
+
+    stdout, ok = @runner.call(["--version"])
+    version = ok ? codex_version_from_output(stdout) : nil
+    parsed = version && safe_version(version)
+
+    if parsed.nil?
+      return check(
+        category: "agent_registration", name: "codex_version_floor", status: "warn",
+        message: "Could not determine the installed Codex version (`codex --version` did not " \
+                 "return a parseable version); Plastic cannot confirm the apply_patch hooks " \
+                 "floor v#{CODEX_HOOKS_FLOOR} is met, so its gate may silently no-op",
+        fixable: false,
+        fix_hint: "Ensure `codex` is on PATH and `codex --version` >= #{CODEX_HOOKS_FLOOR}"
+      )
+    end
+
+    if parsed < safe_version(CODEX_HOOKS_FLOOR)
+      return check(
+        category: "agent_registration", name: "codex_version_floor", status: "warn",
+        message: "Installed Codex #{version} predates v#{CODEX_HOOKS_FLOOR}; the apply_patch " \
+                 "PreToolUse veto only exists from v#{CODEX_HOOKS_FLOOR} (PR #18391), so Plastic's " \
+                 "gate silently no-ops on this install",
+        fixable: false,
+        fix_hint: "Upgrade Codex to v#{CODEX_HOOKS_FLOOR} or newer with your install method " \
+                  "(npm i -g @openai/codex, mise, homebrew, or cargo)"
+      )
+    end
+
+    check(
+      category: "agent_registration", name: "codex_version_floor", status: "pass",
+      message: "Codex #{version} meets the apply_patch hooks floor v#{CODEX_HOOKS_FLOOR}"
+    )
+  end
+
+  def codex_version_from_output(stdout)
+    m = stdout.to_s.match(/(\d+\.\d+\.\d+(?:[.\-+][0-9A-Za-z.\-+]*)?)/)
+    m && m[1]
+  end
+
+  def safe_version(str)
+    Gem::Version.new(str.to_s)
+  rescue ArgumentError
+    nil
+  end
+
   # --- Check category 4: Core files ---
 
   def check_core_files(agent_key)

package/scripts/lib/agent_models.rb

@@ -31,6 +31,10 @@ module AgentModels
   # 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
@@ -45,6 +49,21 @@ module AgentModels
     "haiku" => "low"
   }.freeze
 
+  # Codex model id per tier alias (intent 186). Codex has NO vendor alias layer: every model id
+  # is a literal versioned string that rots (gpt-5.2 / gpt-5.3-codex already deprecated), which is
+  # why 116 D1 / 102a Decision B refused to pin a raw id per role file. This resolves that by
+  # 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>.
+  CODEX_MODEL_BY_ALIAS = {
+    "opus" => "gpt-5.6-sol",
+    "sonnet" => "gpt-5.6-terra",
+    "haiku" => "gpt-5.6-luna"
+  }.freeze
+
   module_function
 
   # Pull { basename => model } out of a loaded config hash's `agents.models`
@@ -85,4 +104,10 @@ module AgentModels
   def effort_for(value)
     EFFORT_BY_ALIAS[value.to_s]
   end
+
+  # The Codex model id for a Plastic tier alias, or nil for any value that is not one of the three
+  # shipped aliases (the caller then treats the value as a literal Codex model id, or omits it).
+  def codex_model_for(value)
+    CODEX_MODEL_BY_ALIAS[value.to_s]
+  end
 end

package/scripts/lib/installer_core.rb

@@ -613,8 +613,8 @@ class InstallerCore
   end
 
   # Render one repo agents/*.md into a deterministic Codex agent TOML document. Fixed field
-  # order (name, description, one model field, developer_instructions) so regenerate is
-  # byte-identical (idempotency).
+  # 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)
     front, body = split_frontmatter(File.read(source_path))
     name = (front["name"] || File.basename(source_path, ".md")).to_s
@@ -641,14 +641,21 @@ class InstallerCore
     end
   end
 
-  # The single model-selection line. A known tier alias (opus/sonnet/haiku) emits
-  # model_reasoning_effort only; any other non-empty value is a literal Codex model id
-  # emitted verbatim as `model`. Empty -> no line (the agent inherits the session default).
+  # 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)
     return "" if effective.nil? || effective.to_s.empty?
     effort = AgentModels.effort_for(effective)
     if effort
-      %(model_reasoning_effort = "#{effort}")
+      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.join("\n")
     else
       %(model = "#{toml_inline_escape(effective.to_s)}")
     end