brainiac 0.0.27 → 0.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 889b0c7491371dd4deb7dc5a173eb5c45045cf9d85a9bf1b5cfcf75bb233d407
-  data.tar.gz: c5532f51f711e5b5839fd3c9cbfe3e297e8ae00849a44b9b82331d13d5d318f0
+  metadata.gz: add3489f7ad183254936da1957e45221696ba277bc1119fd243cdde74c8114a8
+  data.tar.gz: 9fbc0a541c50978c549327528f4f64383735b386dd6688a9d38dae4353a04542
 SHA512:
-  metadata.gz: 81735abd0d5d4dc9e9aeccaf3ae80e7c51f3ca529f759750e0dc8ad4f3f15a3bee54ea3169f96e9a6e3a7b378d8395940e9b5af10bd92e8117d0fc49a602d855
-  data.tar.gz: 71bfdf3580bbe77aa873be4d7ef211b42f9f19979efce7a76cdcbfdeb30c914bdf9dae48b32d571bf28ad9871f53c1fd92946f025e36d7d9aa2a4e2b38ad4df5
+  metadata.gz: 063130f40cb32c62a13e3fb5cf1c036d88e17f25e76243c3724f56e49776ffbaed5f025efc8a03b6792da24917d615665f5169147dfa3e28ed4ac9da5c63b1c7
+  data.tar.gz: a57864221e958f731ce29d77a9a2322eda834f4efd63bd83109dd326bcafbe749592a47fe29b1bc76ada0e51dc74380f76079802c3881b9465e66d2aea4cc653

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    brainiac (0.0.27)
+    brainiac (0.0.28)
       puma (~> 7.2)
       rackup (~> 2.3)
       sinatra (~> 4.1)
@@ -84,7 +84,7 @@ DEPENDENCIES
 CHECKSUMS
   ast (2.4.3) sha256=954615157c1d6a382bc27d690d973195e79db7f55e9765ac7c481c60bdb4d383
   base64 (0.3.0) sha256=27337aeabad6ffae05c265c450490628ef3ebd4b67be58257393227588f5a97b
-  brainiac (0.0.27)
+  brainiac (0.0.28)
   json (2.19.9) sha256=9b9025b7cdddafa38d316eca0b2358488e42d417045c1b90d216a9fefe46b79a
   language_server-protocol (3.17.0.5) sha256=fd1e39a51a28bf3eec959379985a72e296e9f9acfce46f6a79d31ca8760803cc
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87

data/README.md

@@ -226,12 +226,23 @@ Configure which AI CLI to use for dispatching agents. Each provider is a JSON fi
 
 ```json
 {
-  "agent_cli": "kiro-cli",
-  "agent_cli_args": "chat --trust-all-tools --no-interactive",
-  "agent_model_flag": "--model"
+  "binary": "kiro-cli",
+  "default_args": "chat --trust-all-tools --no-interactive",
+  "agent_flag": "--agent",
+  "model_flag": "--model"
 }
 ```
 
+The `agent_flag` field controls how agent identity is passed to the CLI. Different CLIs use different flags:
+
+| CLI | `agent_flag` | Example command |
+|-----|-------------|-----------------|
+| Kiro CLI | `"--agent"` | `kiro-cli --agent sherlock chat --no-interactive` |
+| Codex CLI | `"--profile"` | `codex --profile sherlock exec --sandbox workspace-write -` |
+| Grok CLI | `null` | `grok --always-approve` (no agent identity passed) |
+
+Set `agent_flag` to `null` to suppress passing the agent name entirely (for CLIs that don't support persona switching).
+
 Brainiac ships with example providers during setup. Your project config references which provider to use.
 
 #### 3. Environment Variables

data/bin/brainiac

@@ -205,6 +205,7 @@ def wait_for_agents_to_finish
   end
 end
 
+# rubocop:disable Naming/PredicateMethod
 def stop_server
   pid = find_server_pid
 
@@ -245,6 +246,7 @@ def stop_server
     false
   end
 end
+# rubocop:enable Naming/PredicateMethod
 
 # Kill a single process: TERM first, KILL if it doesn't exit within 5s.
 def kill_pid(pid, quiet: false)
@@ -1025,6 +1027,9 @@ def brain_list
   puts "Run 'brainiac brain init <agent-name>' to set up a new agent."
 end
 
+# Model output parsing (shared with lib/brainiac/helpers.rb)
+require_relative "../lib/brainiac/model_parser"
+
 # Main CLI
 options = {}
 subcommand = ARGV.shift
@@ -1940,6 +1945,150 @@ when "provider"
     File.write(file, JSON.pretty_generate(scaffold))
     puts "Created #{file} — edit it to configure the provider."
 
+  when "list-models"
+    name = ARGV[0]
+    unless name
+      puts "Usage: brainiac provider list-models <name>"
+      exit 1
+    end
+    file = File.join(providers_dir, "#{name}.json")
+    unless File.exist?(file)
+      puts "Provider '#{name}' not found."
+      exit 1
+    end
+    data = JSON.parse(File.read(file))
+    command = data["list_models_command"]
+    if command.nil? || command.empty?
+      puts "Provider '#{name}' has no list_models_command configured."
+      puts "Edit #{file} and set \"list_models_command\" to a shell command that lists models."
+      puts "Example: \"kiro-cli chat --list-models --format json\""
+      exit 1
+    end
+
+    puts "Querying models from '#{name}' (#{command})..."
+    puts ""
+    stdout, stderr, status = Open3.capture3(command)
+    unless status.success?
+      puts "Command failed (exit #{status.exitstatus}):"
+      puts stderr.strip unless stderr.empty?
+      exit 1
+    end
+
+    models = parse_list_models_output(stdout)
+    if models.nil? || models.empty?
+      puts "No models found in command output."
+      puts "Raw output:"
+      puts stdout
+      exit 1
+    end
+
+    # Filter hidden models (e.g. codex "visibility": "hide") unless none are visible
+    visible_models = models.select { |m| m["visibility"].nil? || m["visibility"] != "hide" }
+    visible_models = models if visible_models.empty?
+
+    # Display models in a table
+    default_model = data["default_model"]
+    # Determine default: explicit default_model field > parsed "default" flag > first model
+    has_explicit_default = default_model && visible_models.any? { |m| m["model_id"] == default_model }
+    has_parsed_default = !has_explicit_default && visible_models.any? { |m| m["default"] }
+    puts "Available models for '#{name}' (#{visible_models.size} visible, #{models.size} total):"
+    puts ""
+    visible_models.each do |m|
+      model_id = m["model_id"] || "unknown"
+      desc = m["description"] || m["display_name"] || ""
+      rate = m["rate_multiplier"] ? "#{m["rate_multiplier"]}x" : (m["rate"] || "")
+      marker = if has_explicit_default
+                 m["model_id"] == default_model ? "*" : " "
+               elsif has_parsed_default
+                 m["default"] ? "*" : " "
+               else
+                 m == visible_models.first ? "*" : " "
+               end
+      if desc.empty?
+        puts "  #{marker} #{model_id}"
+      else
+        puts format("  %<marker>s %-25<model>s %-15<rate>s %<desc>s", marker: marker, model: model_id, rate: rate, desc: desc)
+      end
+    end
+
+    # Show which are mapped vs unmapped
+    configured = data["models"] || {}
+    configured_ids = configured.values
+    unmapped = visible_models.select do |m|
+      id = m["model_id"]
+      !configured_ids.include?(id) && !configured.key?(id)
+    end
+    unless unmapped.empty?
+      puts ""
+      puts "#{unmapped.size} model(s) not in your provider's 'models' map:"
+      unmapped.each { |m| puts "  - #{m["model_id"]}" }
+      puts ""
+      puts "Run 'brainiac provider sync-models #{name}' to add them."
+    end
+
+  when "sync-models"
+    name = ARGV[0]
+    unless name
+      puts "Usage: brainiac provider sync-models <name>"
+      exit 1
+    end
+    file = File.join(providers_dir, "#{name}.json")
+    unless File.exist?(file)
+      puts "Provider '#{name}' not found."
+      exit 1
+    end
+    data = JSON.parse(File.read(file))
+    command = data["list_models_command"]
+    if command.nil? || command.empty?
+      puts "Provider '#{name}' has no list_models_command configured."
+      exit 1
+    end
+
+    stdout, stderr, status = Open3.capture3(command)
+    unless status.success?
+      puts "Command failed (exit #{status.exitstatus}): #{stderr.strip}"
+      exit 1
+    end
+
+    models = parse_list_models_output(stdout)
+    if models.nil? || models.empty?
+      puts "No models found in command output."
+      exit 1
+    end
+
+    # Build a models map from discovered models: key = short name, value = model_id
+    existing_models = data["models"] || {}
+    new_models = existing_models.dup
+    added = []
+
+    models.each do |m|
+      model_id = m["model_id"]
+      next unless model_id
+
+      # Skip hidden models (e.g. codex internal models)
+      next if m["visibility"] == "hide"
+
+      # Skip if already mapped (as key or value)
+      next if new_models.value?(model_id) || new_models.key?(model_id)
+
+      # Generate a short key: strip common prefixes, use the base name
+      short_key = generate_short_model_key(model_id)
+      # If the short key already exists, use the full model_id as the key
+      short_key = model_id if new_models.key?(short_key)
+      new_models[short_key] = model_id
+      added << "#{short_key} => #{model_id}"
+    end
+
+    if added.empty?
+      puts "All discovered models are already mapped. Nothing to sync."
+      exit 0
+    end
+
+    data["models"] = new_models
+    File.write(file, JSON.pretty_generate(data))
+    puts "Synced #{added.size} new model(s) to #{file}:"
+    added.each { |a| puts "  + #{a}" }
+
   else
     puts <<~HELP
       Usage: brainiac provider <command>
@@ -1948,6 +2097,8 @@ when "provider"
         list                 List configured CLI providers
         show <name>          Show provider configuration
         add <name>           Create a new provider config
+        list-models <name>   Query available models from the CLI provider
+        sync-models <name>   Add discovered models to provider config
     HELP
   end
 
@@ -3474,7 +3625,7 @@ when "plugin"
     gem_name = "brainiac-#{plugin_name}"
 
     # Determine the base repo path (strip worktree suffix like --branch-name)
-    base_path = current_path.sub(/--[^\/]+$/, "")
+    base_path = current_path.sub(%r{--[^/]+$}, "")
     unless Dir.exist?(base_path)
       puts "Error: Base repo not found at #{base_path}"
       exit 1
@@ -3503,9 +3654,7 @@ when "plugin"
     # Fetch latest to make sure the branch is available
     puts "Fetching latest from origin..."
     _out, _err, fetch_status = Open3.capture3("git", "fetch", "origin", chdir: base_path)
-    unless fetch_status.success?
-      puts "Warning: git fetch failed — continuing with local state."
-    end
+    puts "Warning: git fetch failed — continuing with local state." unless fetch_status.success?
 
     # Check if a worktree already exists for this branch
     worktree_list, _, wt_status = Open3.capture3("git", "worktree", "list", "--porcelain", chdir: base_path)
@@ -3513,18 +3662,19 @@ when "plugin"
 
     if wt_status.success?
       # Parse porcelain output to find worktrees on the target branch
-      worktrees = worktree_list.split("\n\n").map do |block|
+      worktree_blocks = worktree_list.split("\n\n").map do |block|
         wt = {}
         block.each_line do |line|
           case line
           when /^worktree (.+)/
             wt[:path] = Regexp.last_match(1).strip
-          when /^branch refs\/heads\/(.+)/
+          when %r{^branch refs/heads/(.+)}
             wt[:branch] = Regexp.last_match(1).strip
           end
         end
         wt
-      end.select { |wt| wt[:path] && wt[:branch] }
+      end
+      worktrees = worktree_blocks.select { |wt| wt[:path] && wt[:branch] }
 
       target_worktree = worktrees.find { |wt| wt[:branch] == branch_name }
     end
@@ -3541,11 +3691,9 @@ when "plugin"
       File.write(plugins_file, JSON.pretty_generate(plugins_config))
       puts "✓ Switched plugin '#{plugin_name}' to branch '#{branch_name}'"
       puts "  Path: #{new_path}"
-      puts "  Restart the server to apply: brainiac restart"
     else
       # Check if branch exists remotely or locally
-      branch_exists = false
-      check_cmd, _, check_status = Open3.capture3("git", "rev-parse", "--verify", "origin/#{branch_name}", chdir: base_path)
+      _, _, check_status = Open3.capture3("git", "rev-parse", "--verify", "origin/#{branch_name}", chdir: base_path)
       branch_exists = check_status.success?
 
       unless branch_exists
@@ -3576,7 +3724,10 @@ when "plugin"
       _, _, local_check = Open3.capture3("git", "rev-parse", "--verify", branch_name, chdir: base_path)
       if !local_check.success? && check_status.success?
         # Remote branch exists but not local — create tracking branch in worktree
-        _, stderr, wt_status = Open3.capture3("git", "worktree", "add", "--track", "-b", branch_name, worktree_dir, "origin/#{branch_name}", chdir: base_path)
+        _, stderr, wt_status = Open3.capture3(
+          "git", "worktree", "add", "--track", "-b", branch_name, worktree_dir,
+          "origin/#{branch_name}", chdir: base_path
+        )
       else
         # Local branch exists — use it directly
         _, stderr, wt_status = Open3.capture3("git", "worktree", "add", worktree_dir, branch_name, chdir: base_path)
@@ -3592,8 +3743,8 @@ when "plugin"
       File.write(plugins_file, JSON.pretty_generate(plugins_config))
       puts "✓ Switched plugin '#{plugin_name}' to branch '#{branch_name}'"
       puts "  Worktree: #{worktree_dir}"
-      puts "  Restart the server to apply: brainiac restart"
     end
+    puts "  Restart the server to apply: brainiac restart"
 
   else
     puts "Usage: brainiac plugin <command>"

data/docs/resume.md

@@ -0,0 +1,87 @@
+# Resume Session Integration
+
+Brainiac supports resuming prior agent sessions instead of starting fresh. Two patterns exist:
+
+## Flag-Based Resume (e.g. Kiro `--resume`, Grok `-c`)
+
+The CLI appends a flag to the existing command. The base command structure stays the same.
+
+```
+kiro-cli --agent sherlock chat --trust-all-tools --no-interactive --resume
+grok --always-approve -c
+```
+
+Provider config:
+
+```json
+{
+  "resume_flag": "--resume"
+}
+```
+
+## Subcommand-Based Resume (e.g. Codex `exec resume --last`)
+
+The CLI changes the subcommand entirely. The base command structure is replaced.
+
+```
+codex exec --full-auto          →  codex exec resume --last --full-auto
+```
+
+Provider config:
+
+```json
+{
+  "resume_flag": null,
+  "resume_args": "exec resume --last --full-auto",
+  "session_dir": "~/.codex/sessions"
+}
+```
+
+When `resume_args` is set, it replaces `default_args` entirely during resume. The `session_dir` field tells Brainiac where to look for prior sessions (for CLIs that store session state centrally rather than in the project directory).
+
+## Plugin Integration Contract
+
+Plugins that want to support resume MUST:
+
+1. **Use `resume_viable?`** to check whether a session can be resumed:
+
+   ```ruby
+   can_resume = resume_viable?(project_config: config, chdir: worktree_path)
+   ```
+
+2. **Pass `resume: true` to `run_agent`** — core handles the rest:
+
+   ```ruby
+   run_agent(prompt, project_config: config, chdir: worktree_path, resume: can_resume)
+   ```
+
+Plugins MUST NOT:
+- Check `resolved["resume_flag"]` directly (misses `resume_args` providers)
+- Call `resolve_resume` directly (internal to `run_agent`)
+- Build their own resume command logic
+
+## How It Works Internally
+
+```
+Plugin calls run_agent(..., resume: true)
+  → run_agent calls resolve_resume(true, resolved, chdir)
+    → resolve_resume checks resume_flag OR resume_args is configured
+    → resolve_resume calls prior_session_exists?(chdir, cli, session_dir:)
+      → For centralized session dirs: scans .jsonl files for matching cwd
+      → For local session dirs: checks for .grok/, .kiro-cli/, or recent logs
+    → Returns :resume_args, flag string, or false
+  → run_agent passes result to build_agent_cmd
+    → :resume_args → replace default_args with resume_args
+    → String flag → append to command
+    → false → normal command (no resume)
+```
+
+## Session Detection
+
+### Local (flag-based CLIs)
+
+Checks for CLI-specific dotdirs (`.grok/`, `.kiro-cli/`) or recent agent logs in `tmp/` (last 24 hours).
+
+### Centralized (subcommand-based CLIs)
+
+Scans `session_dir` for `.jsonl` files modified in the last 24 hours whose first-line JSON metadata contains a `payload.cwd` matching the target working directory. Handles symlink resolution (e.g. `/var/folders` vs `/private/var/folders` on macOS).

data/lib/brainiac/cron.rb

@@ -596,10 +596,12 @@ def build_cron_agent_cmd(job, project, prompt_file: nil)
   resolved = resolve_project_cli_config(project, agent_name: job[:agent])
   agent_flag = resolved.key?("agent_flag") ? resolved["agent_flag"] : "--agent"
   cmd = [resolved["agent_cli"]]
+  # cwd_flag: pass the working directory as a CLI argument (e.g. -C for Codex CLI).
+  cmd.push(resolved["cwd_flag"], project["repo_path"]) if resolved["cwd_flag"] && project["repo_path"]
   cmd.push(agent_flag, agent_config_name) if agent_flag
   cmd.concat(resolved["agent_cli_args"].split)
   cmd.push(resolved["agent_model_flag"], job[:model]) if resolved["agent_model_flag"]&.length&.positive? && job[:model]
-  cmd.push(resolved["agent_effort_flag"], job[:effort]) if resolved["agent_effort_flag"]&.length&.positive? && job[:effort]
+  append_effort_to_cmd(cmd, job[:effort], resolved)
   cmd.push(resolved["prompt_flag"], prompt_file) if prompt_file && resolved["prompt_mode"] == "flag" && resolved["prompt_flag"]
   cmd
 end

data/lib/brainiac/handlers/shared/git.rb

@@ -172,37 +172,12 @@ def create_or_reuse_worktree(repo_path:, branch:, base_ref: nil, worktree_path:
   base_ref ||= "origin/#{get_default_branch(repo_path)}"
 
   worktree_list = run_cmd("git", "worktree", "list", "--porcelain", chdir: repo_path)
-
-  if File.directory?(worktree_path)
-    is_tracked = worktree_list.include?(worktree_path)
-
-    if is_tracked
-      LOG.info "Worktree directory #{worktree_path} is tracked by git"
-    else
-      LOG.warn "Orphaned worktree directory found at #{worktree_path}, removing it"
-      begin
-        FileUtils.rm_rf(worktree_path)
-        LOG.info "Successfully removed orphaned directory"
-      rescue StandardError => e
-        LOG.error "Failed to remove orphaned directory: #{e.message}"
-        raise
-      end
-    end
-  end
+  cleanup_orphaned_worktree(worktree_path, worktree_list) if File.directory?(worktree_path)
 
   branch_exists = system("git", "rev-parse", "--verify", branch, chdir: repo_path, out: File::NULL, err: File::NULL)
 
   if branch_exists
-    LOG.info "Branch #{branch} already exists, checking for existing worktree"
-    worktree_list = run_cmd("git", "worktree", "list", "--porcelain", chdir: repo_path)
-    has_worktree = worktree_list.lines.any? { |line| line.strip == "worktree #{worktree_path}" }
-
-    if has_worktree && File.directory?(worktree_path)
-      LOG.info "Reusing existing worktree at #{worktree_path}"
-    else
-      LOG.info "Creating worktree from existing branch #{branch}"
-      run_cmd("git", "worktree", "add", worktree_path, branch, chdir: repo_path)
-    end
+    attach_or_create_worktree_for_branch(repo_path, branch, worktree_path)
   else
     LOG.info "Creating new branch #{branch} and worktree"
     run_cmd("git", "worktree", "add", "-b", branch, worktree_path, base_ref, chdir: repo_path)
@@ -215,6 +190,56 @@ def create_or_reuse_worktree(repo_path:, branch:, base_ref: nil, worktree_path:
   worktree_path
 end
 
+# Remove an orphaned worktree directory (exists on disk but not tracked by git).
+# If the directory is tracked, logs and leaves it alone.
+def cleanup_orphaned_worktree(worktree_path, worktree_list)
+  resolved_path = begin
+    File.realpath(worktree_path)
+  rescue StandardError
+    worktree_path
+  end
+  is_tracked = worktree_list.include?(worktree_path) || worktree_list.include?(resolved_path)
+
+  if is_tracked
+    LOG.info "Worktree directory #{worktree_path} is tracked by git"
+  else
+    LOG.warn "Orphaned worktree directory found at #{worktree_path}, removing it"
+    begin
+      FileUtils.rm_rf(worktree_path)
+      LOG.info "Successfully removed orphaned directory"
+    rescue StandardError => e
+      LOG.error "Failed to remove orphaned directory: #{e.message}"
+      raise
+    end
+  end
+end
+
+# Attach an existing branch to a worktree, reusing it if already present.
+def attach_or_create_worktree_for_branch(repo_path, branch, worktree_path)
+  LOG.info "Branch #{branch} already exists, checking for existing worktree"
+  worktree_list = run_cmd("git", "worktree", "list", "--porcelain", chdir: repo_path)
+  # Resolve symlinks for comparison (macOS /var/folders vs /private/var/folders)
+  resolved_wt = begin
+    File.realpath(worktree_path)
+  rescue StandardError
+    worktree_path
+  end
+  has_worktree = worktree_list.lines.any? do |line|
+    stripped = line.strip
+    next false unless stripped.start_with?("worktree ")
+
+    listed_path = stripped.sub("worktree ", "")
+    listed_path == worktree_path || listed_path == resolved_wt
+  end
+
+  if has_worktree && File.directory?(worktree_path)
+    LOG.info "Reusing existing worktree at #{worktree_path}"
+  else
+    LOG.info "Creating worktree from existing branch #{branch}"
+    run_cmd("git", "worktree", "add", worktree_path, branch, chdir: repo_path)
+  end
+end
+
 # Find an existing worktree for a card by scanning the filesystem.
 def find_worktree_for_card(card_number, repo_path:)
   return nil unless card_number

data/lib/brainiac/helpers.rb

@@ -18,7 +18,9 @@ def load_cli_provider(provider_name)
     "agent_cli" => raw["binary"],
     "agent_cli_args" => raw["default_args"],
     "agent_model_flag" => raw["model_flag"],
+    "agent_model" => raw["agent_model"],
     "agent_effort_flag" => raw["effort_flag"],
+    "agent_effort" => raw["agent_effort"],
     "allowed_models" => raw["models"],
     "allowed_efforts" => raw["efforts"]
   }
@@ -28,10 +30,15 @@ def load_cli_provider(provider_name)
   config["agent_flag"] = raw.key?("agent_flag") ? raw["agent_flag"] : "--agent"
   # prompt_mode: "stdin" (default) or "flag" — how the prompt is delivered.
   config["prompt_mode"] = raw["prompt_mode"] || "stdin"
-  config["prompt_flag"] = raw["prompt_flag"] if raw["prompt_flag"]
-  # resume_flag: when set, follow-up dispatches use this flag to continue the
-  # most recent session in the working directory (e.g. "-c" or "--continue").
-  config["resume_flag"] = raw["resume_flag"] if raw["resume_flag"]
+  # Copy optional fields from raw config when present.
+  # Each field controls a specific CLI behavior — see comments in the template.
+  %w[prompt_flag list_models_command resume_flag resume_args session_dir output_last_message_flag
+     cwd_flag config_override_flag effort_config_key effort_map].each do |key|
+    next unless raw[key]
+    next if raw[key].respond_to?(:empty?) && raw[key].empty?
+
+    config[key] = raw[key]
+  end
   # Compact nil values except agent_flag (which uses nil to mean "don't pass agent name")
   agent_flag_value = config["agent_flag"]
   config.compact!
@@ -42,6 +49,30 @@ rescue JSON::ParserError => e
   {}
 end
 
+# Run a CLI provider's list_models_command and return the parsed model list.
+# Returns an array of model hashes on success, or nil on failure.
+# Each model hash contains at least: "model_id" (or "slug"/"model_name"), and optionally "description", etc.
+def list_models_for_provider(provider_name)
+  config = load_cli_provider(provider_name)
+  return nil if config.empty?
+
+  command = config["list_models_command"]
+  return nil unless command && !command.empty?
+
+  stdout, stderr, status = Open3.capture3(command)
+  unless status.success?
+    LOG.warn "list_models_command for '#{provider_name}' failed (exit #{status.exitstatus}): #{stderr.strip}"
+    return nil
+  end
+
+  parse_list_models_output(stdout)
+rescue StandardError => e
+  LOG.warn "Failed to run list_models_command for '#{provider_name}': #{e.message}"
+  nil
+end
+
+require_relative "model_parser"
+
 # Resolve CLI config for a project by merging provider defaults with project overrides.
 # Priority: cli_provider_override > agent-level cli_provider > project-level cli_provider > DEFAULT_PROJECT
 def resolve_project_cli_config(project_config, cli_provider_override: nil, agent_name: nil)
@@ -435,17 +466,26 @@ end
 # Check if a prior CLI session exists in the given directory for the specified CLI binary.
 # This prevents resume attempts when the CLI provider changed (e.g., [cli:grok] in a thread
 # started by kiro-cli) or when the session was started on a different machine.
-def prior_session_exists?(chdir, agent_cli)
+# session_dir: optional centralized session directory (e.g. ~/.codex/sessions) for CLIs
+# that store session state globally rather than per-project.
+def prior_session_exists?(chdir, agent_cli, session_dir: nil)
   return false unless chdir && agent_cli
 
   cli_name = File.basename(agent_cli)
 
+  # Centralized session storage (e.g. Codex stores sessions in ~/.codex/sessions/).
+  # Search session files for ones that match the working directory (cwd field in session metadata).
+  if session_dir
+    expanded_session_dir = File.expand_path(session_dir)
+    return centralized_session_matches_cwd?(expanded_session_dir, chdir) if File.directory?(expanded_session_dir)
+  end
+
   # Check for CLI-specific session markers:
   # - grok uses .grok/ directory for session state
   # - kiro-cli uses .kiro-cli/ or similar
   # - Generic fallback: check tmp/ for agent logs from this CLI
-  session_dir = File.join(chdir, ".#{cli_name}")
-  return true if File.directory?(session_dir)
+  session_dir_local = File.join(chdir, ".#{cli_name}")
+  return true if File.directory?(session_dir_local)
 
   # Fallback: look for recent session logs in tmp/ that suggest this CLI ran here before.
   # This covers CLIs that don't leave a dotdir but do leave logs via brainiac.
@@ -460,9 +500,60 @@ rescue StandardError
   false
 end
 
+# Check if a centralized session directory has sessions matching the given cwd.
+# Supports CLIs that store sessions as .jsonl files in date-partitioned directories (YYYY/MM/DD/)
+# with a first-line JSON metadata object containing a "payload.cwd" field.
+# Only considers sessions from the last 24 hours as resumable.
+#
+# Performance note: Dir.glob("**/*.jsonl") stats every file in the session directory before
+# filtering by mtime. This is fine for typical usage (days/weeks of sessions) but could slow
+# down if the directory accumulates months of files. The 24-hour mtime cutoff limits actual
+# I/O (only recent files are read), but the glob itself still walks the full tree.
+def centralized_session_matches_cwd?(session_base_dir, target_cwd)
+  # Only check recent session files (last 24 hours) to avoid scanning the full history
+  cutoff = Time.now - 86_400
+  target_cwd_resolved = begin
+    File.realpath(target_cwd)
+  rescue StandardError
+    target_cwd
+  end
+
+  Dir.glob(File.join(session_base_dir, "**", "*.jsonl")).any? do |session_file|
+    next unless File.mtime(session_file) > cutoff
+
+    # Read just the first line to get session_meta with cwd
+    first_line = begin
+      File.open(session_file, &:readline)
+    rescue StandardError
+      next
+    end
+    meta = begin
+      JSON.parse(first_line)
+    rescue StandardError
+      next
+    end
+    session_cwd = meta.dig("payload", "cwd")
+    next unless session_cwd
+
+    session_cwd_resolved = begin
+      File.realpath(session_cwd)
+    rescue StandardError
+      session_cwd
+    end
+    session_cwd_resolved == target_cwd_resolved
+  end
+rescue StandardError
+  false
+end
+
 # Public helper: check if resume is viable for a given project + CLI provider combo.
-# Plugins should call this BEFORE building the prompt to decide between
-# render_resume_prompt (lean) and render_prompt (full context).
+# Plugins MUST use this method (not check resolved["resume_flag"] directly) to decide
+# whether a session can be resumed. This handles both flag-based resume (e.g. kiro --resume,
+# grok -c) and subcommand-based resume (e.g. codex exec resume --last).
+#
+# Call this BEFORE building the prompt to decide between:
+#   - render_resume_prompt (lean, for resumable sessions)
+#   - render_prompt with full context (for non-resumable sessions)
 #
 # Returns true if the CLI supports resume AND a prior session exists in the working directory.
 # When this returns false, plugins should use render_prompt with thread history as card_context
@@ -470,17 +561,24 @@ end
 def resume_viable?(project_config:, cli_provider: nil, agent_name: nil, chdir: nil)
   resolved = resolve_project_cli_config(project_config, cli_provider_override: cli_provider, agent_name: agent_name)
   chdir ||= resolved["repo_path"]
-  return false unless resolved["resume_flag"]
+  return false unless resolved["resume_flag"] || resolved["resume_args"]
 
-  prior_session_exists?(chdir, resolved["agent_cli"])
+  prior_session_exists?(chdir, resolved["agent_cli"], session_dir: resolved["session_dir"])
 end
 
 # Determine whether a session resume should actually happen.
-# Returns truthy (the resume flag string) if viable, false otherwise.
-# Logs a message when resume was requested but isn't possible.
+# Called by run_agent — plugins should NOT call this directly; pass `resume: true` to run_agent.
+#
+# Returns:
+#   - :resume_args — when the provider uses subcommand-based resume (build_agent_cmd replaces default_args)
+#   - String (the resume flag) — when the provider uses flag-based resume (appended to cmd)
+#   - false — when resume was not requested or not viable
 def resolve_resume(resume, resolved, chdir)
-  return false unless resume && resolved["resume_flag"]
-  return resolved["resume_flag"] if prior_session_exists?(chdir, resolved["agent_cli"])
+  return false unless resume && (resolved["resume_flag"] || resolved["resume_args"])
+  if prior_session_exists?(chdir, resolved["agent_cli"], session_dir: resolved["session_dir"])
+    # Return :resume_args when the provider uses subcommand-based resume (e.g. Codex exec resume)
+    return resolved["resume_args"] ? :resume_args : resolved["resume_flag"]
+  end
 
   LOG.info "[Dispatch] Resume requested but not viable for #{resolved["agent_cli"]} in #{chdir} — starting fresh session"
   false
@@ -505,6 +603,10 @@ def intent_skip?(message, agent_name:, source: nil, channel: nil, context: nil)
   false
 end
 
+# Dispatch an agent CLI process. Plugins call this with `resume: true` to request session
+# continuation — the method internally resolves whether to use flag-based resume (appending
+# e.g. --resume or -c) or subcommand-based resume (replacing default_args with resume_args).
+# Plugins should NOT build their own resume logic; pass `resume: true` and let core handle it.
 def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil, effort: nil, agent_name: nil, card_number: nil, comment_id: nil,
               source: nil, source_context: {}, skip_column_move: false, cli_provider: nil, resume: false,
               message: nil, channel: nil, context: nil, env: {})
@@ -528,14 +630,17 @@ def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil
   FileUtils.mkdir_p(File.dirname(log_file))
 
   prompt_file = write_agent_prompt_file(prompt, log_name, timestamp)
-  cmd = build_agent_cmd(resolved, agent_config_name: agent_config_name, model: model, effort: effort, prompt_file: prompt_file, resume: should_resume)
+  output_file = prepare_output_file(resolved, log_name, timestamp)
+
+  cmd = build_agent_cmd(resolved, agent_config_name: agent_config_name, model: model, effort: effort,
+                                  prompt_file: prompt_file, resume: should_resume,
+                                  output_file: output_file, chdir: chdir)
   prompt_mode = resolved["prompt_mode"] || "stdin"
 
   spawn_env = agent_env_for(agent_name).merge(env)
 
   LOG.info "Running #{resolved["agent_cli"]} in #{chdir}, logging to #{log_file}"
-  LOG.info "Prompt written to #{prompt_file}"
-  LOG.info "Command: #{cmd.join(" ")}#{" (resuming session)" if should_resume}"
+  LOG.info "Prompt: #{prompt_file} | Output: #{output_file || "none"} | Command: #{cmd.join(" ")}#{" (resuming session)" if should_resume}"
   LOG.info "Injecting #{spawn_env.size} env var(s) for agent #{agent_name}: #{spawn_env.keys.join(", ")}" unless spawn_env.empty?
 
   project_key_for_restart = PROJECTS.find { |_k, v| v == project_config }&.first
@@ -555,6 +660,7 @@ def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil
       prompt_file: prompt_file, chdir: chdir, source: source,
       source_context: source_context, project_config: project_config,
       card_number: card_number, skip_column_move: skip_column_move,
+      output_file: output_file,
       head_before: head_before, status_before: status_before,
       project_key_for_restart: project_key_for_restart
     )
@@ -575,32 +681,104 @@ def write_agent_prompt_file(prompt, log_name, timestamp)
   prompt_file
 end
 
+# Generate output file path for structured output capture (--output-last-message).
+# Returns nil if the provider doesn't support it.
+def prepare_output_file(resolved, log_name, timestamp)
+  return nil unless resolved["output_last_message_flag"]
+
+  output_dir = File.join(BRAINIAC_DIR, "tmp", "output")
+  FileUtils.mkdir_p(output_dir)
+  File.join(output_dir, "agent-#{log_name}-#{timestamp}.md")
+end
+
+# Read the structured output file written by the agent CLI (--output-last-message).
+# Returns the file content as a string, or nil if the file doesn't exist or is empty.
+def read_output_file(output_file)
+  return nil unless output_file && File.exist?(output_file)
+
+  content = File.read(output_file).strip
+  if content.empty?
+    LOG.info "[Output] Output file exists but is empty: #{output_file}"
+    return nil
+  end
+
+  LOG.info "[Output] Captured structured output (#{content.bytesize} bytes) from #{output_file}"
+  content
+rescue StandardError => e
+  LOG.warn "[Output] Failed to read output file #{output_file}: #{e.message}"
+  nil
+end
+
 # Build the CLI command array for an agent invocation.
 # When prompt_file is provided and prompt_mode is "flag", appends the prompt as a CLI argument.
-# When resume is true and the provider has a resume_flag, adds it to continue the last session.
-def build_agent_cmd(resolved, agent_config_name: nil, model: nil, effort: nil, prompt_file: nil, resume: false)
+# When resume is truthy and the provider has a resume_flag, adds it to continue the last session.
+# When resume is :resume_args, uses resume_args as the args instead of default_args (subcommand-based resume).
+# When output_file is provided and the provider has output_last_message_flag, appends it.
+# When chdir is provided and the provider has a cwd_flag, appends it so the CLI
+# itself switches to the working directory (e.g. `codex -C /path/to/project`).
+# rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+def build_agent_cmd(resolved, agent_config_name: nil, model: nil, effort: nil, prompt_file: nil, resume: false, output_file: nil, chdir: nil)
   cmd = [resolved["agent_cli"]]
+  # cwd_flag: pass the working directory as a CLI argument (e.g. -C for Codex CLI).
+  # This is added early so it appears before subcommands/args (global option).
+  cmd.push(resolved["cwd_flag"], chdir) if resolved["cwd_flag"] && chdir
   # agent_flag controls how the agent identity is passed. Defaults to "--agent".
   # Provider configs can set it to a different flag or null to suppress entirely.
   agent_flag = resolved.key?("agent_flag") ? resolved["agent_flag"] : "--agent"
   cmd.push(agent_flag, agent_config_name) if agent_flag && agent_config_name
-  cmd.concat(resolved["agent_cli_args"].split)
+  # When resuming via subcommand (resume_args), replace default_args entirely.
+  # e.g. "exec --full-auto" becomes "exec resume --last --full-auto"
+  args = resume == :resume_args && resolved["resume_args"] ? resolved["resume_args"] : resolved["agent_cli_args"]
+  cmd.concat(args.split)
   # Only pass --model if the model is a valid ID for this provider.
   # "auto" means "let the CLI choose" — skip passing it unless the provider explicitly maps it.
   if model && resolved["agent_model_flag"] && !resolved["agent_model_flag"].empty?
     allowed = resolved["allowed_models"] || {}
-    # Pass the model if it's a mapped value (e.g. "claude-opus-4.5") or the key itself is mapped
-    is_known = allowed.value?(model) || allowed.key?(model)
-    cmd.push(resolved["agent_model_flag"], model) if is_known
+    # If the model is a key in allowed_models, use the mapped value (e.g. "auto" -> "o4-mini")
+    # This handles cases where different projects use "auto" but each CLI provider maps it differently.
+    effective_model = allowed.key?(model) ? allowed[model] : model
+    is_known = allowed.value?(effective_model) || allowed.key?(effective_model)
+    cmd.push(resolved["agent_model_flag"], effective_model) if is_known
   end
-  cmd.push(resolved["agent_effort_flag"], effort) if resolved["agent_effort_flag"] && !resolved["agent_effort_flag"].empty? && effort
-  # Resume the most recent session in the working directory (for multi-turn CLIs like grok)
-  cmd.push(resolved["resume_flag"]) if resume && resolved["resume_flag"]
+  append_effort_to_cmd(cmd, effort, resolved) if effort
+  # Resume via flag (simple append, e.g. grok -c or kiro --resume) — only when not using resume_args
+  cmd.push(resume) if resume && resume != :resume_args && resume.is_a?(String)
   # prompt_mode: "flag" passes the prompt file path via the configured prompt_flag (e.g. --prompt-file).
   cmd.push(resolved["prompt_flag"], prompt_file) if prompt_file && resolved["prompt_mode"] == "flag" && resolved["prompt_flag"]
+  # output_last_message_flag: capture the agent's final message to a file (e.g. codex exec -o <path>).
+  cmd.push(resolved["output_last_message_flag"], output_file) if output_file && resolved["output_last_message_flag"]
   cmd
 end
+# rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+# Map a Brainiac effort level through the provider's effort_map (if any).
+# Returns the mapped level, or the original level if no mapping exists.
+def map_effort_level(effort, resolved)
+  return nil unless effort
+
+  effort_map = resolved["effort_map"]
+  return effort unless effort_map
+
+  effort_map[effort] || effort
+end
+
+# Append effort flags to a command array based on provider config.
+# Handles both dedicated effort flags (--effort high) and config overrides (-c 'key="value"').
+def append_effort_to_cmd(cmd, effort, resolved)
+  return unless effort
+
+  mapped_effort = map_effort_level(effort, resolved)
+  return unless mapped_effort
+
+  if resolved["effort_config_key"]
+    flag = resolved["config_override_flag"] || "-c"
+    cmd.push(flag, "#{resolved["effort_config_key"]}=\"#{mapped_effort}\"")
+  elsif resolved["agent_effort_flag"] && !resolved["agent_effort_flag"].empty?
+    cmd.push(resolved["agent_effort_flag"], mapped_effort)
+  end
+end
 
+# Append --model flag if the model is valid for this provider.
 def handle_agent_completion(**ctx)
   agent_exit_status = $CHILD_STATUS.exitstatus
   agent_signaled = $CHILD_STATUS.signaled?
@@ -614,6 +792,9 @@ def handle_agent_completion(**ctx)
     )
   end
 
+  # Read structured output if the provider wrote to an output file (--output-last-message).
+  output_content = read_output_file(ctx[:output_file])
+
   # Emit lifecycle hook — plugins handle post-session actions (e.g., plugin moves card, appends footer)
   Brainiac.emit(:agent_completed,
                 card_number: ctx[:card_number] || ctx[:source_context]&.dig(:card_number),
@@ -625,7 +806,12 @@ def handle_agent_completion(**ctx)
                 source_context: ctx[:source_context],
                 project_config: ctx[:project_config],
                 skip_column_move: ctx[:skip_column_move],
-                prompt_file: ctx[:prompt_file])
+                prompt_file: ctx[:prompt_file],
+                output_file: ctx[:output_file],
+                output_content: output_content)
+
+  # Clean up the output file after hook emission (content already captured above).
+  FileUtils.rm_f(ctx[:output_file]) if ctx[:output_file]
 
   qmd_out, qmd_status = Open3.capture2e("qmd", "update")
   if qmd_status.success?
@@ -656,8 +842,10 @@ def check_brainiac_restart(head_before, status_before, chdir, project_key_for_re
   end
 end
 
-def detect_model(project_config, tags: [], text: "", cli_provider_override: nil)
-  resolved = resolve_project_cli_config(project_config, cli_provider_override: cli_provider_override)
+def detect_model(project_config, tags: [], text: "", cli_provider_override: nil, agent_name: nil)
+  # If no explicit CLI provider override, check if the agent has one configured
+  effective_cli_provider = cli_provider_override || agent_cli_provider_for(agent_name)
+  resolved = resolve_project_cli_config(project_config, cli_provider_override: effective_cli_provider, agent_name: agent_name)
   allowed_models = resolved["allowed_models"] || {}
   return resolved["agent_model"] if allowed_models.empty?
 
@@ -678,8 +866,9 @@ end
 # Returns the effort level string (e.g. "high") or nil.
 # If the requested level isn't supported by the current model, returns the closest
 # lower level from allowed_efforts.
-def detect_effort(project_config, tags: [], text: "", cli_provider_override: nil)
-  resolved = resolve_project_cli_config(project_config, cli_provider_override: cli_provider_override)
+def detect_effort(project_config, tags: [], text: "", cli_provider_override: nil, agent_name: nil)
+  effective_cli_provider = cli_provider_override || agent_cli_provider_for(agent_name)
+  resolved = resolve_project_cli_config(project_config, cli_provider_override: effective_cli_provider, agent_name: agent_name)
   allowed = resolved["allowed_efforts"] || %w[low medium high xhigh max]
 
   # Inline tag: [effort:high] — works in any channel

data/lib/brainiac/intent.rb

@@ -113,7 +113,7 @@ def validate_intent_model!(config)
   end
 
   true
-rescue Errno::ECONNREFUSED
+rescue Errno::ECONNREFUSED, Socket::ResolutionError, Errno::EADDRNOTAVAIL
   raise "Ollama is not running at #{config["endpoint"]}. Start it with: ollama serve"
 rescue Net::OpenTimeout, Net::ReadTimeout
   LOG.warn "[Intent] Could not validate model (Ollama timed out) — will check at first use"

data/lib/brainiac/model_parser.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+# Standalone model output parsing — shared between bin/brainiac (CLI) and lib/brainiac/helpers.rb (server).
+# No dependencies beyond Ruby stdlib (json).
+
+require "json"
+
+# Parse the output of a list_models_command.
+# Supports JSON output with a "models" array, or plain text lines with model names.
+# Normalizes various field names (slug, model_name) to "model_id" for consistency.
+def parse_list_models_output(output)
+  return nil if output.nil? || output.strip.empty?
+
+  # Try parsing the entire output as JSON first (handles well-formed JSON from any CLI)
+  begin
+    data = JSON.parse(output)
+    return normalize_model_list(data["models"]) if data.is_a?(Hash) && data["models"].is_a?(Array)
+    return normalize_model_list(data) if data.is_a?(Array)
+  rescue JSON::ParserError
+    # Not pure JSON — try to extract JSON from mixed output
+  end
+
+  # Some CLIs output non-JSON text before the JSON (like kiro-cli with --format json).
+  # Try parsing from any line that starts with "{" — handles both single-line JSON and
+  # pretty-printed JSON where "models" is on a subsequent line.
+  lines = output.lines
+  lines.each_with_index do |line, idx|
+    next unless line.strip.start_with?("{")
+
+    json_candidate = lines[idx..].join
+    begin
+      data = JSON.parse(json_candidate)
+      return normalize_model_list(data["models"]) if data.is_a?(Hash) && data["models"].is_a?(Array)
+    rescue JSON::ParserError
+      # Try next candidate
+    end
+  end
+
+  # Try to find a standalone JSON array starting with [{ (e.g. codex debug models raw output)
+  # Intentionally separate loop: {models:[]} has priority over bare arrays
+  lines.each_with_index do |line, idx| # rubocop:disable Style/CombinableLoops
+    next unless line.strip.start_with?("[{", "[")
+
+    json_candidate = lines[idx..].join
+    begin
+      data = JSON.parse(json_candidate)
+      return normalize_model_list(data) if data.is_a?(Array) && data.first.is_a?(Hash)
+    rescue JSON::ParserError
+      # Try next candidate
+    end
+  end # rubocop:enable Style/CombinableLoops
+
+  # Fallback: parse plain text output (one model per line, or tabular format)
+  parse_list_models_text(output)
+end
+
+# Parse plain text model listing (e.g. "* auto   1.00x credits   Description here")
+# Lines prefixed with "*" are marked as the default model.
+def parse_list_models_text(output)
+  models = []
+  output.each_line do |line|
+    line = line.strip
+    next if line.empty? || line.start_with?("Available") || line.start_with?("Default")
+
+    is_default = line.start_with?("*")
+
+    # Match lines like: "* auto   1.00x credits   Description" or "  claude-sonnet-4.6   1.30x credits   Desc"
+    if (m = line.match(/^[*\s]*(\S+)\s+(\d+\.\d+x\s+\w+)\s+(.+)$/))
+      entry = { "model_id" => m[1], "rate" => m[2].strip, "description" => m[3].strip }
+      entry["default"] = true if is_default
+      models << entry
+    elsif (m = line.match(/^[*\s]*(\S+)\s*$/))
+      entry = { "model_id" => m[1] }
+      entry["default"] = true if is_default
+      models << entry
+    end
+  end
+  models.empty? ? nil : models
+end
+
+# Generate a short key from a model_id for use in the models config map.
+# Strips common provider prefixes, lowercases, and normalizes to kebab-case.
+# Examples:
+#   "claude-sonnet-4.6" => "sonnet-4-6"
+#   "GPT-4o"            => "4o"
+#   "DeepSeek-V3"       => "deepseek-v3"
+def generate_short_model_key(model_id)
+  model_id
+    .downcase
+    .sub(/^claude-/, "")
+    .sub(/^grok-/, "")
+    .sub(/^gpt-/, "")
+    .gsub(/[^a-z0-9]/, "-").squeeze("-")
+    .sub(/^-/, "")
+    .sub(/-$/, "")
+end
+
+# Normalize model hashes to always have "model_id" as the primary identifier.
+# Handles various CLI output formats: "slug" (codex), "model_name" (generic), "model_id" (kiro-cli).
+# Silently skips non-Hash elements (e.g. strings or numbers in a mixed array).
+def normalize_model_list(models)
+  models.grep(Hash).map do |m|
+    next m if m["model_id"]
+
+    m = m.dup
+    m["model_id"] = m.delete("slug") || m.delete("model_name") || "unknown"
+    m
+  end
+end

data/lib/brainiac/version.rb

@@ -2,5 +2,5 @@
 
 module Brainiac
   # @return [String] the current gem version
-  VERSION = "0.0.27"
+  VERSION = "0.0.28"
 end

data/monitor/waybar/session_slot.rb

@@ -18,9 +18,7 @@ INFRA_CMDS = %w[kiro-cli-chat ruby-lsp clangd gopls].freeze
 DISCORD_CONFIG_FILE = File.join(BRAINIAC_DIR, "discord.json")
 
 index = ARGV.find { |a| !a.start_with?("--") }&.to_i
-unless index
-  exit
-end
+exit unless index
 
 def load_discord_guild_id
   return nil unless File.exist?(DISCORD_CONFIG_FILE)

data/templates/cli-providers/codex.json.example

@@ -0,0 +1,32 @@
+{
+  "binary": "codex",
+  "default_args": "--full-auto",
+  "agent_flag": "--profile",
+  "model_flag": "--model",
+  "agent_model": "gpt-5.6-terra",
+  "effort_flag": null,
+  "effort_config_key": "model_reasoning_effort",
+  "config_override_flag": "-c",
+  "effort_map": {
+    "low": "low",
+    "medium": "medium",
+    "high": "high",
+    "xhigh": "xhigh",
+    "max": "xhigh"
+  },
+  "prompt_mode": "stdin",
+  "cwd_flag": "-C",
+  "resume_flag": null,
+  "resume_args": "exec resume --last --full-auto",
+  "session_dir": "~/.codex/sessions",
+  "output_last_message_flag": "-o",
+  "list_models_command": "codex debug models",
+  "models": {
+    "sol": "gpt-5.6-sol",
+    "terra": "gpt-5.6-terra",
+    "luna": "gpt-5.6-luna",
+    "gpt5.5": "gpt-5.5",
+    "auto": "gpt-5.6-terra"
+  },
+  "efforts": ["low", "medium", "high", "xhigh", "max"]
+}

data/templates/cli-providers/grok.json.example

@@ -7,6 +7,7 @@
   "prompt_mode": "flag",
   "prompt_flag": "--prompt-file",
   "resume_flag": "-c",
+  "list_models_command": "grok models",
   "models": {
     "build": "grok-build",
     "composer": "grok-composer-2.5-fast",

data/templates/cli-providers/kiro.json.example

@@ -6,6 +6,7 @@
   "effort_flag": "--effort",
   "prompt_mode": "stdin",
   "resume_flag": "--resume",
+  "list_models_command": "kiro-cli chat --list-models --format json",
   "models": {
     "opus": "claude-opus-4.5",
     "sonnet": "claude-sonnet-4.6",

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac
 version: !ruby/object:Gem::Version
-  version: 0.0.27
+  version: 0.0.28
 platform: ruby
 authors:
 - Andy Davis
@@ -123,6 +123,7 @@ files:
 - bin/brainiac
 - bin/brainiac-completion.bash
 - brainiac.gemspec
+- docs/resume.md
 - docs/waybar-config.md
 - lib/brainiac.rb
 - lib/brainiac/agents.rb
@@ -134,6 +135,7 @@ files:
 - lib/brainiac/helpers.rb
 - lib/brainiac/hooks.rb
 - lib/brainiac/intent.rb
+- lib/brainiac/model_parser.rb
 - lib/brainiac/notifications.rb
 - lib/brainiac/plugins.rb
 - lib/brainiac/prompts.rb
@@ -159,6 +161,7 @@ files:
 - skills/brainiac-plugins/SKILL.md
 - templates/agents.json.example
 - templates/brainiac.json.example
+- templates/cli-providers/codex.json.example
 - templates/cli-providers/grok.json.example
 - templates/cli-providers/kiro.json.example
 - templates/hooks/pre-commit