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

package/scripts/lib/store_layout.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Plastic
+  module StoreLayout
+    GLOBAL = "global"
+    PARENTS = %w[stores projects].freeze
+
+    module_function
+
+    def moved?(home)
+      File.directory?(File.join(home, "stores"))
+    end
+
+    def global_root(home)
+      moved?(home) ? File.join(home, "stores", GLOBAL) : home
+    end
+
+    def global_store(home)
+      File.join(global_root(home), "store")
+    end
+
+    def projects_root(home)
+      File.join(home, moved?(home) ? "stores" : "projects")
+    end
+
+    def project_root(home, slug)
+      File.join(projects_root(home), slug)
+    end
+
+    def root(home, slug)
+      (slug == GLOBAL) ? global_root(home) : project_root(home, slug)
+    end
+
+    def project_slugs(home)
+      parent = projects_root(home)
+      return [] unless File.directory?(parent)
+
+      Dir.children(parent).reject { |entry| entry.start_with?(".") || entry == GLOBAL }.sort
+    end
+
+    def locate(store)
+      root = File.dirname(File.expand_path(store))
+      parent = File.dirname(root)
+      return [root, GLOBAL] unless PARENTS.include?(File.basename(parent))
+
+      [File.dirname(parent), File.basename(root)]
+    end
+
+    def home_and_scope(store)
+      home, slug = locate(store)
+      [home, (slug == GLOBAL) ? GLOBAL : "project:#{slug}"]
+    end
+  end
+end

package/scripts/lib/store_provisioning.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
+require_relative "store_layout"
 require "fileutils"
 require "yaml"
 
@@ -63,7 +64,7 @@ module StoreProvisioning
       }
     end
 
-    project_dir = File.join(plastic_home, "projects", slug)
+    project_dir = Plastic::StoreLayout.project_root(plastic_home, slug)
     store_dir = File.join(project_dir, "store")
     FileUtils.mkdir_p(store_dir)
 

package/scripts/lib/store_sync.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "open3"
+require "tempfile"
+require_relative "search_index"
+require_relative "reference_archive"
+require_relative "work_graph"
+
+module Plastic
+  module StoreSync
+    INTENT_PATH = %r{\A(?:(?:projects|stores)/([^/]+)/)?store/([^/]+?)--}
+    ROW_HASH = "lower(hex(sha3(sqlar_uncompress(data, sz), 256)))"
+
+    def self.action(state)
+      file, row, recorded = state.values_at("file", "row", "hash")
+      return "write" if file.nil?
+      return if file == row
+      return "read" if row == recorded
+      return "write" if file == recorded
+
+      "conflict"
+    end
+
+    def self.plan(home)
+      known = states(home)
+      fresh = SearchIndex.files(home) - known.map { |state| state["path"] }
+      plan = known.map { |state| [action(state), state["path"]] } + fresh.map { |file| ["read", file] }
+      plan.select(&:first).sort_by(&:last)
+    end
+
+    def self.states(home)
+      Sqlite.call(SearchIndex.path(home), <<~SQL, readonly: true)
+        SELECT path, lower(hex(sha3(readfile(#{Sqlite.quote(home)} || '/' || path), 256))) AS file, #{ROW_HASH} AS row, hash
+        FROM doc;
+      SQL
+    end
+
+    def self.apply(home, plan)
+      statements = plan.map { |action, path| send(action, home, path) }
+      statements << "INSERT INTO ft(ft) VALUES('rebuild');" if plan.any? { |action, _path| action == "read" }
+      Sqlite.call(SearchIndex.path(home), ["BEGIN;", *statements, "COMMIT;"].join("\n"))
+    end
+
+    def self.read(home, path)
+      "DELETE FROM doc WHERE path = #{Sqlite.quote(path)};\n#{SearchIndex.insert(home, path)}"
+    end
+
+    def self.write(home, path)
+      where = "WHERE path = #{Sqlite.quote(path)}"
+      "#{restore(home, "doc", "path")} #{where};\nUPDATE doc SET hash = #{ROW_HASH} #{where};"
+    end
+
+    def self.restore(home, table, column)
+      "SELECT writefile(#{Sqlite.quote(home)} || '/' || #{column}, sqlar_uncompress(data, sz)) FROM #{table}"
+    end
+
+    def self.diff(home, path)
+      body = Sqlite.call(SearchIndex.path(home), <<~SQL, readonly: true).first["body"]
+        SELECT CAST(sqlar_uncompress(data, sz) AS TEXT) AS body FROM doc WHERE path = #{Sqlite.quote(path)};
+      SQL
+      Tempfile.create("plastic-row") do |row|
+        row.write(body)
+        row.flush
+        Open3.capture2("diff", "-u", "-L", "row", "-L", "file", row.path, File.join(home, path)).first
+      end
+    end
+
+    def self.orphans(home)
+      paths = Sqlite.call(SearchIndex.path(home), "SELECT path FROM doc;", readonly: true) +
+        Sqlite.call(ReferenceArchive.path(home), "SELECT name AS path FROM sqlar;", readonly: true)
+      keys = paths.filter_map { |row| row["path"].match(INTENT_PATH) }.map { |found| "#{found[1] || "global"}:#{found[2]}" }
+      (keys.uniq - WorkGraph.known(home)).sort
+    end
+
+    def self.checkout(home)
+      {SearchIndex.path(home) => %w[doc path], ReferenceArchive.path(home) => %w[sqlar name]}.flat_map do |database, (table, column)|
+        missing = Sqlite.call(database, "SELECT #{column} AS path FROM #{table};", readonly: true)
+          .map { |row| row["path"] }.reject { |path| File.exist?(File.join(home, path)) }
+        names = missing.map { |path| Sqlite.quote(path) }.join(", ")
+        Sqlite.call(database, "#{restore(home, table, column)} WHERE #{column} IN (#{names});", readonly: true)
+        missing
+      end
+    end
+  end
+end

package/scripts/lib/stores_move.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "store_layout"
+require_relative "sqlite"
+require_relative "lock"
+
+module Plastic
+  class StoresMove
+    Refused = Class.new(StandardError)
+
+    GLOBAL_ENTRIES = %w[store INDEX.md roadmaps].freeze
+    PATH_COLUMNS = {"knowledge_graph.db" => %w[doc path], "references.db" => %w[sqlar name]}.freeze
+    LOCKS = "{store,projects/*/store}/*/delivery.lock"
+
+    def initialize(home, qmd_index:, dry_run: false)
+      @home = home
+      @qmd_index = qmd_index
+      @dry_run = dry_run
+    end
+
+    def call
+      refuse
+      plan = [["copy", copy]] + moves.map { |from, to| ["move", "#{from} -> #{to}"] } + rewrites.map { |file| ["rewrite", file] }
+      run unless @dry_run
+      plan
+    end
+
+    def copy
+      "#{@home}-before-stores-move"
+    end
+
+    private
+
+    def refuse
+      raise Refused, "#{File.join(@home, "stores")}/ exists, so this home has moved already" if StoreLayout.moved?(@home)
+      raise Refused, "a delivery lock is held: #{held.join(", ")}" unless held.empty?
+      raise Refused, "#{copy} exists; remove it or move it away first" if File.exist?(copy)
+    end
+
+    def held
+      Dir.glob(LOCKS, base: @home).select { |lock| Time.now - File.mtime(File.join(@home, lock)) < Lock::TTL_SECONDS }
+    end
+
+    def moves
+      @moves ||= GLOBAL_ENTRIES.select { |name| File.exist?(File.join(@home, name)) }.map { |name| [name, "stores/global/#{name}"] } +
+        project_entries.map { |entry| ["projects/#{entry}", "stores/#{entry}"] }
+    end
+
+    def project_entries
+      Dir.exist?(projects) ? Dir.children(projects).sort : []
+    end
+
+    def projects
+      File.join(@home, "projects")
+    end
+
+    def rewrites
+      [File.join(@home, "config.yml"), @qmd_index, *PATH_COLUMNS.keys.map { |name| File.join(@home, name) }].select { |file| File.file?(file) }
+    end
+
+    def run
+      files = rewrites
+      FileUtils.cp_r(@home, copy, preserve: true)
+      moves.each { |from, to| move(from, to) }
+      FileUtils.rmdir(projects) if Dir.exist?(projects)
+      files.each { |file| PATH_COLUMNS.key?(File.basename(file)) ? rewrite_rows(file) : rewrite_text(file) }
+    end
+
+    def move(from, to)
+      FileUtils.mkdir_p(File.dirname(File.join(@home, to)))
+      FileUtils.mv(File.join(@home, from), File.join(@home, to))
+    end
+
+    def rewrite_text(file)
+      FileUtils.cp(file, "#{file}.before-stores-move", preserve: true)
+      File.write(file, [@home, "~/.plastic"].inject(File.read(file)) { |text, base| relocate(text, base) })
+    end
+
+    def relocate(text, base)
+      text.gsub(%r{#{Regexp.escape(base)}/(store|roadmaps|INDEX\.md)\b}) { "#{base}/stores/global/#{Regexp.last_match(1)}" }
+        .gsub(%r{#{Regexp.escape(base)}/projects\b}) { "#{base}/stores" }
+    end
+
+    def rewrite_rows(file)
+      table, column = PATH_COLUMNS.fetch(File.basename(file))
+      Sqlite.call(file, <<~SQL)
+        UPDATE #{table} SET #{column} = 'stores/' || substr(#{column}, 10) WHERE #{column} LIKE 'projects/%';
+        UPDATE #{table} SET #{column} = 'stores/global/' || #{column} WHERE #{column} LIKE 'store/%';
+      SQL
+    end
+  end
+end

package/scripts/lib/verify_intent.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
+require_relative "store_layout"
 require_relative "worktree"
 require_relative "scaffold_intent"
 
@@ -96,13 +97,7 @@ module VerifyIntent
   # shapes are told apart by whether store's grandparent is literally named "projects" (the
   # StoreDiscovery convention), never by hardcoding ".plastic" as a name.
   def resolve_plastic_home_and_scope(store)
-    parent = File.dirname(store)
-    grandparent = File.dirname(parent)
-    if File.basename(grandparent) == "projects"
-      [File.dirname(grandparent), "project:#{File.basename(parent)}"]
-    else
-      [parent, "global"]
-    end
+    Plastic::StoreLayout.home_and_scope(store)
   end
 
   # --- check 1: doctor, scoped to the intent --------------------------------------

package/scripts/lib/version_number.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# VersionNumber - dotted version comparison without RubyGems (intent 363).
+#
+# The launcher starts as `ruby --disable-gems`, which saves about 26 of the 40
+# milliseconds a plain Ruby process costs, so no file a command loads may reach
+# for Gem::Version. Parses the leading run of dotted integers, ignoring a
+# leading "v" and anything after the digits, and compares two of them segment by
+# segment with the shorter one zero-padded. A string with no leading integer
+# parses to nil, so a caller answers "not found" instead of raising.
+#
+# It deliberately does not order pre-release suffixes: 2.0.0-alpha.27 and 2.0.0
+# compare equal here. A caller that needs RubyGems' pre-release order, such as
+# the release-tag reader in scripts/report-screen, keeps Gem::Version.
+class VersionNumber
+  include Comparable
+
+  LEADING_DIGITS = /\A(\d+(?:\.\d+)*)/
+
+  attr_reader :segments
+
+  def self.parse(value)
+    match = LEADING_DIGITS.match(value.to_s.strip.sub(/\Av/, ""))
+    match && new(match[1].split(".").map(&:to_i))
+  end
+
+  def initialize(segments)
+    @segments = segments
+  end
+
+  def <=>(other)
+    return nil unless other.is_a?(VersionNumber)
+
+    width = [segments.length, other.segments.length].max
+    padded(width) <=> other.padded(width)
+  end
+
+  def to_s
+    segments.join(".")
+  end
+
+  protected
+
+  def padded(width)
+    segments + Array.new(width - segments.length, 0)
+  end
+end

package/scripts/lib/work_graph.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require_relative "sqlite"
+require_relative "index_entry"
+require_relative "store_discovery"
+
+module Plastic
+  module WorkGraph
+    NAME = "work_graph.db"
+    SCHEMA = <<~SQL
+      CREATE TABLE intent(id TEXT, store TEXT, slug TEXT, status TEXT, title TEXT);
+      CREATE TABLE ledger(intent_id TEXT, store TEXT, at TEXT, stage TEXT, text TEXT);
+    SQL
+    STATUSES = %w[active future completed abandoned].freeze
+    LEDGER_LINE = /\A(\S+)\s{2,}(\S+)\s{2,}(.+)\z/
+
+    def self.path(home)
+      File.join(home, NAME)
+    end
+
+    def self.build(home)
+      draft = "#{path(home)}.tmp"
+      FileUtils.rm_f(draft)
+      rows = StoreDiscovery.discover(home)[:stores].flat_map { |store| intents(store) + ledger(store) }
+      Sqlite.call(draft, [SCHEMA, "BEGIN;", *rows, "COMMIT;"].join("\n"))
+      File.rename(draft, path(home))
+    end
+
+    def self.intents(store)
+      return [] unless File.exist?(store[:index])
+
+      status = nil
+      File.readlines(store[:index], chomp: true, encoding: "UTF-8").filter_map do |line|
+        status = line.delete_prefix("## ").downcase if line.start_with?("## ")
+        entry = STATUSES.include?(status) && IndexEntry.match(line)
+        entry && insert("intent", entry[1], store[:slug], File.basename(File.dirname(entry[3])).split("--", 2).last, status, entry[2])
+      end
+    end
+
+    def self.ledger(store)
+      Dir.glob("*/savepoint.md", base: store[:store]).sort.flat_map do |file|
+        id = file.split("--").first
+        File.readlines(File.join(store[:store], file), chomp: true, encoding: "UTF-8").filter_map do |line|
+          entry = line.match(LEDGER_LINE)
+          entry && insert("ledger", id, store[:slug], entry[1], entry[2], entry[3])
+        end
+      end
+    end
+
+    def self.insert(table, *values)
+      "INSERT INTO #{table} VALUES(#{values.map { |value| Sqlite.quote(value.to_s) }.join(", ")});"
+    end
+
+    def self.known(home)
+      Sqlite.call(path(home), "SELECT store, id FROM intent;", readonly: true).map { |row| "#{row["store"]}:#{row["id"]}" }
+    end
+  end
+end

package/scripts/lib/worktree.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
+require_relative "store_layout"
 require "json"
 require "yaml"
 require "socket"
@@ -377,14 +378,8 @@ module Worktree
   # (no project repo). Mirrors qmd_sync's slug_for_store fallback.
   def slug_for_store(store_dir, home: Dir.home)
     return nil if blank?(store_dir)
-    plastic_home = File.expand_path(File.join(home, ".plastic"))
-    store_dir = File.expand_path(store_dir)
-    return nil if store_dir == File.join(plastic_home, "store")
-
-    parts = store_dir.split(File::SEPARATOR)
-    idx = parts.rindex("projects")
-    return parts[idx + 1] if idx && parts[idx + 1] && parts[idx + 2] == "store"
-    nil
+    slug = Plastic::StoreLayout.locate(store_dir).last
+    (slug == Plastic::StoreLayout::GLOBAL) ? nil : slug
   end
 
   # Best-effort slug for the worktree dir-name from an intent dir/store path:

package/scripts/lib/worktree_sweep.rb

@@ -1,6 +1,7 @@
 # encoding: UTF-8
 # frozen_string_literal: true
 
+require_relative "store_layout"
 require_relative "worktree"
 require_relative "index_entry"
 
@@ -55,8 +56,8 @@ module WorktreeSweep
   # Matching on the full name, not just the numeric id, sidesteps id
   # collisions across projects (ids are only unique WITHIN one store).
   def resolve_intent_dir(plastic_home, name)
-    candidates = [File.join(plastic_home, "store", name)] +
-                 Dir.glob(File.join(plastic_home, "projects", "*", "store", name))
+    candidates = [File.join(Plastic::StoreLayout.global_store(plastic_home), name)] +
+                 Dir.glob(File.join(Plastic::StoreLayout.projects_root(plastic_home), "*", "store", name))
     candidates.find { |d| Dir.exist?(d) }
   end
 

package/scripts/link-suggest

@@ -26,6 +26,7 @@
 # nothing. --edge is explicit and required (sources is decided by origin, never
 # inferred); --rating is required when --edge is chain.
 
+require_relative "lib/store_layout"
 require_relative "lib/link_suggestions"
 
 module LinkSuggestCLI
@@ -69,7 +70,7 @@ module LinkSuggestCLI
         i += 1
       end
     end
-    opts[:store_dir] ||= File.join(opts[:home], "store")
+    opts[:store_dir] ||= Plastic::StoreLayout.global_store(opts[:home])
     opts
   end
 

package/scripts/migrate-to-global

@@ -17,7 +17,7 @@ GLOBAL_ROOT="$HOME/.plastic"
 LOCAL_PLASTIC="$PROJECT_PATH/.plastic"
 
 if [ ! -d "$GLOBAL_ROOT" ]; then
-  echo "Error: Global Plastic not installed. Run /plastic-install first." >&2
+  echo "Error: Global Plastic not installed. Run 'plastic install' first." >&2
   exit 1
 fi
 

package/scripts/new-intent

@@ -35,6 +35,7 @@
 # exactly one line, `created <dir>` or `joined <dir>`; exit 0 either way,
 # exit 1 on bad input or failed self-validation.
 
+require_relative "lib/store_layout"
 require "fileutils"
 require "date"
 require_relative "lib/savepoint"
@@ -167,17 +168,7 @@ end
 # [nil, "global"] only if the layout is unrecognized, in which case Links
 # projection falls back to single-store resolution rooted at this store.
 def store_context(store)
-  store = File.expand_path(store)
-  parent = File.dirname(store)               # `<home>` or `<home>/projects/<slug>`
-  if File.basename(store) == "store" && File.basename(File.dirname(parent)) == "projects"
-    slug = File.basename(parent)
-    home = File.dirname(File.dirname(parent)) # strip projects/<slug>
-    [home, "project:#{slug}"]
-  elsif File.basename(store) == "store"
-    [parent, "global"]                        # `<home>/store`
-  else
-    [parent, "global"]
-  end
+  Plastic::StoreLayout.home_and_scope(store)
 end
 
 # The in-scope stores under `plastic_home`, each { key:, store: }. Delegates to
@@ -283,7 +274,7 @@ def run_tmp(opts)
   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"))
+  store = opts[:store] ? expand(opts[:store]) : Plastic::StoreLayout.global_store(expand(ENV.fetch("PLASTIC_HOME", "~/.plastic")))
   templates = opts[:templates] ? expand(opts[:templates]) : default_templates_dir
   abort "new-intent: templates dir not found: #{templates}" unless Dir.exist?(templates)
 

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)

package/scripts/plastic-lock

@@ -38,6 +38,7 @@
 # file; that path was retired in 2.0 (intent 307) and 344 G11.
 # Exit 0 on success/report; exit 1 when the verb is blocked.
 
+require_relative "lib/store_layout"
 require "json"
 require "yaml"
 require_relative "lib/lock"
@@ -96,7 +97,7 @@ if dir.nil? || dir.strip.empty?
     exit 1
   end
   roots = ActiveDelivery.project_roots(plastic_home)
-  global_store = File.join(plastic_home, "store")
+  global_store = Plastic::StoreLayout.global_store(plastic_home)
   dir = ActiveDelivery.resolve(global_store: global_store, project_roots: roots, session: session)
   if dir.nil?
     candidates = ActiveDelivery.candidate_intent_dirs(global_store: global_store, project_roots: roots).uniq
@@ -188,7 +189,7 @@ when "arm"
   end
 when "status"
   lock = Lock.read(dir)
-  resolved = ActiveDelivery.resolve(global_store: File.join(plastic_home, "store"),
+  resolved = ActiveDelivery.resolve(global_store: Plastic::StoreLayout.global_store(plastic_home),
                                     project_roots: ActiveDelivery.project_roots(plastic_home),
                                     session: key)
   delivering = !resolved.nil? && File.expand_path(resolved) == File.expand_path(dir)

package/scripts/promote-session-item

@@ -21,6 +21,7 @@
 # Exit codes: 0 promoted (prints the intent dir last), 1 new-intent failed,
 # 2 usage error or nothing to promote.
 
+require_relative "lib/store_layout"
 require "open3"
 require "yaml"
 require_relative "lib/session_ledger"
@@ -61,7 +62,7 @@ usage_abort("--day must be a real calendar date, YYYYMMDD") unless SessionLedger
 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")
+store = opts[:store] || Plastic::StoreLayout.global_store(plastic_home)
 templates = opts[:templates] || File.expand_path("../templates", __dir__)
 session = opts[:session] ? SessionLedger.short_session_id(opts[:session]) : nil
 
@@ -69,7 +70,7 @@ 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")
+  target_store = File.join(Plastic::StoreLayout.project_root(plastic_home, opts[:project]), "store")
 end
 
 # --- pick the target line ---------------------------------------------------

package/scripts/read-config

@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
-# Usage: read-config <key> [--default VALUE] [--project PATH]
+# Usage: read-config <key> [--default VALUE] [--project PATH] [--harness claude|codex]
 # Resolves a config value: project -> global -> built-in defaults.
 # Nested keys use dot notation: agent.type, architect.style
 # Returns scalar values as strings, hash/array values as JSON.
@@ -46,6 +46,7 @@ def parse_args(argv)
   key = nil
   default_val = nil
   project_dir = nil
+  harness = nil
 
   i = 0
   while i < argv.length
@@ -58,13 +59,17 @@ def parse_args(argv)
       abort "Error: --project requires a value" unless argv[i + 1]
       project_dir = argv[i + 1]
       i += 2
+    when "--harness"
+      abort "Error: --harness requires a value" unless argv[i + 1]
+      harness = argv[i + 1]
+      i += 2
     else
       key = argv[i]
       i += 1
     end
   end
 
-  [key, default_val, project_dir]
+  [key, default_val, project_dir, harness]
 end
 
 def load_yaml(path)
@@ -119,10 +124,10 @@ if ARGV.include?("--migrate")
   exit 0
 end
 
-key, explicit_default, project_dir = parse_args(ARGV)
+key, explicit_default, project_dir, harness = parse_args(ARGV)
 
 if key.nil? || key.empty?
-  $stderr.puts "Usage: read-config <key> [--default VALUE] [--project PATH]"
+  $stderr.puts "Usage: read-config <key> [--default VALUE] [--project PATH] [--harness claude|codex]"
   exit 1
 end
 
@@ -135,9 +140,42 @@ if project_dir
   project_config = load_yaml(project_config_path)
 end
 
-value = dig_key(project_config, key)
-value = dig_key(global_config, key) if value.nil?
+def canonical_harness(value)
+  return nil if value.nil?
+  return "claude" if %w[claude claude-code].include?(value.to_s)
+  return "codex" if value.to_s == "codex"
+
+  abort "Error: --harness must be claude or codex"
+end
+
+def harness_agent_value(config, key, harness)
+  match = key.match(/\Aagents\.(models|efforts)\.([^.]+)\z/)
+  return nil unless match
+
+  section, agent = match.captures
+  if section == "models"
+    AgentModels.models_section(config, harness: harness)[agent]
+  else
+    AgentModels.efforts_section(config, harness)[agent]
+  end
+end
+
+harness = canonical_harness(harness)
+if harness
+  value = harness_agent_value(project_config, key, harness)
+  value = harness_agent_value(global_config, key, harness) if value.nil?
+else
+  value = dig_key(project_config, key)
+  value = dig_key(global_config, key) if value.nil?
+end
 value = explicit_default if value.nil? && explicit_default
+if value.nil? && harness && (match = key.match(/\Aagents\.(models|efforts)\.([^.]+)\z/))
+  value = if match[1] == "models"
+            AgentModels.shipped_model_for(match[2], harness: harness)
+          else
+            AgentModels::DEFAULT_EFFORT
+          end
+end
 value = dig_key(DEFAULTS, key) if value.nil?
 
 puts format_value(value)