brainiac 0.0.2 → 0.0.4

data/lib/brainiac/handlers/fizzy.rb

@@ -143,6 +143,7 @@ def handle_card_assigned(payload)
   branch = "fizzy-#{card_number}-#{slugify(title)}"
   model = detect_model(project_config, tags: tags)
   effort = detect_effort(project_config, tags: tags)
+  cli_provider_override = detect_cli_provider(tags: tags)
 
   card_key = "card-#{card_number}"
   if session_active?(card_key)
@@ -274,7 +275,7 @@ def handle_card_assigned(payload)
            end
 
   pid, log_file = run_agent(prompt, project_config: project_config, chdir: worktree_path, log_name: "assigned-#{card_number}", model: model, effort: effort, agent_name: agent_name,
-                                    card_number: card_number, source: :fizzy, source_context: { card_number: card_number })
+                                    card_number: card_number, source: :fizzy, source_context: { card_number: card_number }, cli_provider: cli_provider_override)
   register_session(card_key, pid, log_file: log_file, supersede_key: card_key, agent_name: assigned_agent)
 
   # Move card to Right Now — agent is starting work
@@ -635,8 +636,13 @@ def handle_comment(payload)
     end
   end
 
+  card_tags = eventable.dig("card", "tags") || []
   model = detect_model(project_config, text: plain_text)
-  effort = detect_effort(project_config, tags: tags, text: effort_text_for_detection)
+  effort = detect_effort(project_config, tags: card_tags, text: effort_text_for_detection)
+  cli_provider_override = detect_cli_provider(text: plain_text, tags: card_tags)
+
+  # Strip [cli:X] tag from prompt content
+  plain_text = plain_text.sub(/\[cli:\w+\]/i, "").strip
 
   # Determine which agent should handle this comment.
   #
@@ -826,7 +832,7 @@ def handle_comment(payload)
     pid, log_file = run_agent(prompt, project_config: project_config, chdir: review_worktree_path,
                                       log_name: "review-#{agent_name.downcase}-#{card_number || card_internal_id}", model: model, effort: effort, agent_name: agent_name,
                                       card_number: card_number, comment_id: comment_id,
-                                      source: :fizzy, source_context: { card_number: card_number })
+                                      source: :fizzy, source_context: { card_number: card_number }, cli_provider: cli_provider_override)
     register_session(card_key, pid, log_file: log_file, supersede_key: card_key, agent_name: agent_name)
 
     return [200, { status: "cross_agent_review", agent: agent_name, card_agent: card_assigned_agent,
@@ -912,7 +918,7 @@ def handle_comment(payload)
             work_dir: work_dir, project_config: project_config, project_key: project_key,
             comment_vars: comment_vars, plain_text: plain_text, model: model,
             agent_name: agent_name, comment_id: comment_id, eventable: eventable,
-            deploy_intent: deploy_intent
+            deploy_intent: deploy_intent, cli_provider: cli_provider_override
           )
         end
 
@@ -936,7 +942,7 @@ def handle_comment(payload)
       work_dir: work_dir, project_config: project_config, project_key: project_key,
       comment_vars: comment_vars, plain_text: plain_text, model: model,
       agent_name: agent_name, comment_id: comment_id, eventable: eventable,
-      deploy_intent: deploy_intent
+      deploy_intent: deploy_intent, cli_provider: cli_provider_override
     )
     [200, result.to_json]
   else
@@ -1019,47 +1025,63 @@ def handle_comment(payload)
 
       # Detect planning mode
       card_tags = eventable.dig("card", "tags") || []
-      planning_info = detect_planning_mode(
-        text: plain_text,
-        tags: card_tags,
-        card_internal_id: card_internal_id,
-        card_number: card_number
-      )
-
-      prompt = if planning_info
-                 # Planning mode
-                 card_id = planning_info[:card_id]
-                 LOG.info "[Planning] Planning mode active for mention on card #{card_number || card_internal_id}"
-
-                 render_planning_prompt(PROMPT_MENTION,
-                                        comment_vars.merge(
-                                          "CARD_INTERNAL_ID" => card_internal_id,
-                                          "CARD_ID" => card_id,
-                                          "CARD_NUMBER" => card_number || "N/A",
-                                          "CARD_NUMBER_TEXT" => card_number ? " (##{card_number})" : "",
-                                          "BRANCH" => branch
-                                        ),
-                                        brain_context: build_brain_context(agent_name: agent_name, card_title: card_title, card_number: card_number, project_key: project_key,
-                                                                           comment_body: plain_text, source: :fizzy),
-                                        card_context: prefetch_card_context(card_number, repo_path: worktree_path, agent_name: agent_name),
-                                        agent_name: agent_name)
-               else
-                 render_prompt(PROMPT_MENTION,
-                               comment_vars.merge(
-                                 "CARD_INTERNAL_ID" => card_internal_id,
-                                 "CARD_ID" => card_number || card_internal_id,
-                                 "CARD_NUMBER" => card_number || "N/A",
-                                 "CARD_NUMBER_TEXT" => card_number ? " (##{card_number})" : "",
-                                 "BRANCH" => branch
-                               ),
-                               brain_context: build_brain_context(agent_name: agent_name, card_title: card_title, card_number: card_number, project_key: project_key,
-                                                                  comment_body: plain_text, source: :fizzy),
-                               card_context: prefetch_card_context(card_number, repo_path: worktree_path, agent_name: agent_name),
-                               agent_name: agent_name)
-               end
+
+      # Check if we can resume the existing session (lean prompt) vs full prompt
+      resolved = resolve_project_cli_config(project_config, cli_provider_override: cli_provider_override, agent_name: agent_name)
+      should_resume = resolved["resume_flag"]
+
+      if should_resume
+        prompt = render_resume_prompt(
+          comment_body: plain_text,
+          comment_creator: comment_vars["COMMENT_CREATOR"],
+          comment_id: comment_id,
+          card_number: card_number,
+          agent_name: agent_name
+        )
+        LOG.info "[Resume] Using lean prompt for mention on card #{card_number || card_internal_id} (#{resolved["agent_cli"]})"
+      else
+        planning_info = detect_planning_mode(
+          text: plain_text,
+          tags: card_tags,
+          card_internal_id: card_internal_id,
+          card_number: card_number
+        )
+
+        prompt = if planning_info
+                   # Planning mode
+                   card_id = planning_info[:card_id]
+                   LOG.info "[Planning] Planning mode active for mention on card #{card_number || card_internal_id}"
+
+                   render_planning_prompt(PROMPT_MENTION,
+                                          comment_vars.merge(
+                                            "CARD_INTERNAL_ID" => card_internal_id,
+                                            "CARD_ID" => card_id,
+                                            "CARD_NUMBER" => card_number || "N/A",
+                                            "CARD_NUMBER_TEXT" => card_number ? " (##{card_number})" : "",
+                                            "BRANCH" => branch
+                                          ),
+                                          brain_context: build_brain_context(agent_name: agent_name, card_title: card_title, card_number: card_number, project_key: project_key,
+                                                                             comment_body: plain_text, source: :fizzy),
+                                          card_context: prefetch_card_context(card_number, repo_path: worktree_path, agent_name: agent_name),
+                                          agent_name: agent_name)
+                 else
+                   render_prompt(PROMPT_MENTION,
+                                 comment_vars.merge(
+                                   "CARD_INTERNAL_ID" => card_internal_id,
+                                   "CARD_ID" => card_number || card_internal_id,
+                                   "CARD_NUMBER" => card_number || "N/A",
+                                   "CARD_NUMBER_TEXT" => card_number ? " (##{card_number})" : "",
+                                   "BRANCH" => branch
+                                 ),
+                                 brain_context: build_brain_context(agent_name: agent_name, card_title: card_title, card_number: card_number, project_key: project_key,
+                                                                    comment_body: plain_text, source: :fizzy),
+                                 card_context: prefetch_card_context(card_number, repo_path: worktree_path, agent_name: agent_name),
+                                 agent_name: agent_name)
+                 end
+      end
 
       pid, log_file = run_agent(prompt, project_config: project_config, chdir: worktree_path, log_name: "mention-#{card_number || card_internal_id}", model: model, effort: effort, agent_name: agent_name, card_number: card_number, comment_id: comment_id,
-                                        source: :fizzy, source_context: { card_number: card_number })
+                                        source: :fizzy, source_context: { card_number: card_number }, cli_provider: cli_provider_override, resume: true)
       register_session(card_key, pid, log_file: log_file, supersede_key: card_key, agent_name: agent_name)
       return [200,
               { status: "responded", card_internal_id: card_internal_id, card_number: card_number, branch: branch, worktree: worktree_path,
@@ -1182,7 +1204,7 @@ def handle_comment(payload)
              end
 
     pid, log_file = run_agent(prompt, project_config: project_config, chdir: worktree_path, log_name: "mention-#{card_number || card_internal_id}", model: model, effort: effort, agent_name: agent_name, card_number: card_number, comment_id: comment_id,
-                                      source: :fizzy, source_context: { card_number: card_number })
+                                      source: :fizzy, source_context: { card_number: card_number }, cli_provider: cli_provider_override)
     register_session(card_key, pid, log_file: log_file, supersede_key: card_key, agent_name: agent_name)
     [200,
      { status: "responded", card_internal_id: card_internal_id, card_number: card_number, branch: branch, worktree: worktree_path,
@@ -1193,53 +1215,74 @@ end
 # Dispatch a follow-up comment to the agent. Extracted so it can be called
 # both inline (no active session) and from a queued background thread.
 def dispatch_followup_comment(card_key:, card_number:, card_internal_id:, work_dir:, project_config:, project_key:, comment_vars:, plain_text:,
-                              model:, agent_name:, comment_id:, eventable:, deploy_intent: nil)
+                              model:, agent_name:, comment_id:, eventable:, deploy_intent: nil, cli_provider: nil)
   card_tags = eventable.dig("card", "tags") || []
-  planning_info = detect_planning_mode(
-    text: plain_text,
-    tags: card_tags,
-    card_internal_id: card_internal_id,
-    card_number: card_number
-  )
+  effort = detect_effort(project_config, tags: card_tags, text: plain_text)
+
+  # Determine if we should resume (worktree + provider supports it)
+  is_worktree = work_dir != project_config["repo_path"]
+  resolved = resolve_project_cli_config(project_config, cli_provider_override: cli_provider, agent_name: agent_name)
+  should_resume = is_worktree && resolved["resume_flag"]
+
+  if should_resume
+    # Lean prompt: only the new comment. The previous session
+    # already has role, persona, knowledge, core instructions, and card history.
+    prompt = render_resume_prompt(
+      comment_body: plain_text,
+      comment_creator: comment_vars["COMMENT_CREATOR"],
+      comment_id: comment_id,
+      card_number: card_number,
+      agent_name: agent_name
+    )
+    LOG.info "[Resume] Using lean prompt for follow-up on card #{card_number || card_internal_id} (#{resolved["agent_cli"]})"
+  else
+    # Full prompt: no session to resume, build everything from scratch
+    planning_info = detect_planning_mode(
+      text: plain_text,
+      tags: card_tags,
+      card_internal_id: card_internal_id,
+      card_number: card_number
+    )
 
-  prompt = if planning_info
-             card_id = planning_info[:card_id]
-             LOG.info "[Planning] Planning mode active for card #{card_number || card_internal_id}"
-
-             if work_dir == project_config["repo_path"]
-               render_planning_prompt(PROMPT_FOLLOWUP_NO_WORKTREE,
-                                      comment_vars.merge("CARD_INTERNAL_ID" => card_internal_id, "CARD_ID" => card_id),
-                                      brain_context: build_brain_context(agent_name: agent_name, project_key: project_key, comment_body: plain_text,
-                                                                         source: :fizzy),
-                                      card_context: prefetch_card_context(card_number, repo_path: project_config["repo_path"],
-                                                                                       agent_name: agent_name),
-                                      agent_name: agent_name)
+    prompt = if planning_info
+               card_id = planning_info[:card_id]
+               LOG.info "[Planning] Planning mode active for card #{card_number || card_internal_id}"
+
+               if work_dir == project_config["repo_path"]
+                 render_planning_prompt(PROMPT_FOLLOWUP_NO_WORKTREE,
+                                        comment_vars.merge("CARD_INTERNAL_ID" => card_internal_id, "CARD_ID" => card_id),
+                                        brain_context: build_brain_context(agent_name: agent_name, project_key: project_key, comment_body: plain_text,
+                                                                           source: :fizzy),
+                                        card_context: prefetch_card_context(card_number, repo_path: project_config["repo_path"],
+                                                                                         agent_name: agent_name),
+                                        agent_name: agent_name)
+               else
+                 render_planning_prompt(PROMPT_FOLLOWUP_WORKTREE,
+                                        comment_vars.merge("CARD_NUMBER" => card_number, "CARD_ID" => card_id),
+                                        brain_context: build_brain_context(agent_name: agent_name, card_number: card_number, project_key: project_key, comment_body: plain_text,
+                                                                           source: :fizzy),
+                                        card_context: prefetch_card_context(card_number, repo_path: work_dir, agent_name: agent_name),
+                                        agent_name: agent_name)
+               end
+             elsif work_dir != project_config["repo_path"]
+               render_prompt(PROMPT_FOLLOWUP_WORKTREE,
+                             comment_vars.merge("CARD_NUMBER" => card_number, "CARD_ID" => card_number),
+                             brain_context: build_brain_context(agent_name: agent_name, card_number: card_number, project_key: project_key, comment_body: plain_text,
+                                                                source: :fizzy),
+                             card_context: prefetch_card_context(card_number, repo_path: work_dir, agent_name: agent_name),
+                             agent_name: agent_name)
              else
-               render_planning_prompt(PROMPT_FOLLOWUP_WORKTREE,
-                                      comment_vars.merge("CARD_NUMBER" => card_number, "CARD_ID" => card_id),
-                                      brain_context: build_brain_context(agent_name: agent_name, card_number: card_number, project_key: project_key, comment_body: plain_text,
-                                                                         source: :fizzy),
-                                      card_context: prefetch_card_context(card_number, repo_path: work_dir, agent_name: agent_name),
-                                      agent_name: agent_name)
+               render_prompt(PROMPT_FOLLOWUP_NO_WORKTREE,
+                             comment_vars.merge("CARD_INTERNAL_ID" => card_internal_id, "CARD_ID" => card_internal_id),
+                             brain_context: build_brain_context(agent_name: agent_name, project_key: project_key, comment_body: plain_text,
+                                                                source: :fizzy),
+                             card_context: prefetch_card_context(card_number, repo_path: project_config["repo_path"], agent_name: agent_name),
+                             agent_name: agent_name)
              end
-           elsif work_dir != project_config["repo_path"]
-             render_prompt(PROMPT_FOLLOWUP_WORKTREE,
-                           comment_vars.merge("CARD_NUMBER" => card_number, "CARD_ID" => card_number),
-                           brain_context: build_brain_context(agent_name: agent_name, card_number: card_number, project_key: project_key, comment_body: plain_text,
-                                                              source: :fizzy),
-                           card_context: prefetch_card_context(card_number, repo_path: work_dir, agent_name: agent_name),
-                           agent_name: agent_name)
-           else
-             render_prompt(PROMPT_FOLLOWUP_NO_WORKTREE,
-                           comment_vars.merge("CARD_INTERNAL_ID" => card_internal_id, "CARD_ID" => card_internal_id),
-                           brain_context: build_brain_context(agent_name: agent_name, project_key: project_key, comment_body: plain_text,
-                                                              source: :fizzy),
-                           card_context: prefetch_card_context(card_number, repo_path: project_config["repo_path"], agent_name: agent_name),
-                           agent_name: agent_name)
-           end
+  end
 
   pid, log_file = run_agent(prompt, project_config: project_config, chdir: work_dir, log_name: "followup-#{card_number || card_internal_id}", model: model, effort: effort, agent_name: agent_name, card_number: card_number, comment_id: comment_id,
-                                    source: :fizzy, source_context: { card_number: card_number, card_internal_id: card_internal_id, deploy_intent: deploy_intent })
+                                    source: :fizzy, source_context: { card_number: card_number, card_internal_id: card_internal_id, deploy_intent: deploy_intent }, cli_provider: cli_provider, resume: is_worktree)
   register_session(card_key, pid, log_file: log_file, supersede_key: card_key, agent_name: agent_name)
 
   # Move card to Right Now — agent is actively working again

data/lib/brainiac/helpers.rb

@@ -7,14 +7,9 @@ CLI_PROVIDERS_DIR = File.join(BRAINIAC_DIR, "cli-providers")
 
 # --trust-all-tools alone doesn't bypass the non-interactive deny list in kiro-cli 1.29.8+.
 # Adding --trust-tools with explicit tool names ensures write/exec tools are approved.
+# This is now configured in the kiro provider's default_args instead of being hardcoded here.
 TRUSTED_TOOLS = "execute_bash,fs_write,fs_read,code,grep,glob,web_search,web_fetch,use_subagent,use_aws"
 
-def add_trust_tools!(cmd, agent_cli_args)
-  return if agent_cli_args.include?("--trust-tools")
-
-  cmd.push("--trust-tools", TRUSTED_TOOLS)
-end
-
 # Clean up all worktrees associated with a card: the primary worktree and any
 # cross-agent review worktrees (e.g. glados-fizzy-123-*, threepio-fizzy-123-*).
 # Safe: skips worktrees with uncommitted changes.
@@ -49,24 +44,86 @@ def cleanup_card_worktrees(card_number, repo_path:, primary_worktree: nil, prima
   LOG.info "Card ##{card_number}: cleaned up #{cleaned} worktree(s)" if cleaned.positive?
 end
 
+# Load a CLI provider config from ~/.brainiac/cli-providers/<name>.json.
+# Returns a hash with normalized keys, or {} if not found.
+def load_cli_provider(provider_name)
+  return {} unless provider_name
+
+  provider_file = File.join(CLI_PROVIDERS_DIR, "#{provider_name}.json")
+  return {} unless File.exist?(provider_file)
+
+  raw = JSON.parse(File.read(provider_file))
+  config = {
+    "agent_cli" => raw["binary"],
+    "agent_cli_args" => raw["default_args"],
+    "agent_model_flag" => raw["model_flag"],
+    "agent_effort_flag" => raw["effort_flag"],
+    "allowed_models" => raw["models"],
+    "allowed_efforts" => raw["efforts"]
+  }
+  # agent_flag: how the agent identity is passed (default: "--agent").
+  # Set to null/false in provider JSON to suppress passing agent name entirely.
+  # We must preserve the key even when nil so merges don't lose the "no agent flag" intent.
+  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"]
+  # Compact nil values except agent_flag (which uses nil to mean "don't pass agent name")
+  agent_flag_value = config["agent_flag"]
+  config.compact!
+  config["agent_flag"] = agent_flag_value if raw.key?("agent_flag")
+  config
+rescue JSON::ParserError => e
+  LOG.warn "Failed to parse CLI provider '#{provider_name}': #{e.message}"
+  {}
+end
+
 # Resolve CLI config for a project by merging provider defaults with project overrides.
-# Priority: project-level keys > provider file > DEFAULT_PROJECT
-def resolve_project_cli_config(project_config)
-  provider_config = {}
-  if (provider_name = project_config["cli_provider"])
-    provider_file = File.join(CLI_PROVIDERS_DIR, "#{provider_name}.json")
-    if File.exist?(provider_file)
-      raw = JSON.parse(File.read(provider_file))
-      provider_config = {
-        "agent_cli" => raw["binary"],
-        "agent_cli_args" => raw["default_args"],
-        "agent_model_flag" => raw["model_flag"],
-        "allowed_models" => raw["models"]
-      }
-    end
+# 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)
+  # Determine which CLI provider to use (priority: override > agent > project)
+  provider_name = cli_provider_override
+  provider_name ||= agent_cli_provider_for(agent_name) if agent_name
+  provider_name ||= project_config["cli_provider"]
+
+  provider_config = load_cli_provider(provider_name)
+
+  DEFAULT_PROJECT.merge(provider_config).merge(project_config).tap do |resolved|
+    # If an override or agent-level provider was used, it should win over the
+    # project-level cli_provider's config. Re-apply the override provider on top.
+    resolved.merge!(provider_config) if provider_name && provider_name != project_config["cli_provider"]
+  end
+end
+
+# Get the cli_provider configured at the agent level in agents.json.
+def agent_cli_provider_for(agent_name)
+  return nil unless agent_name
+
+  key = agent_name.downcase.gsub(/[^a-z0-9-]/, "-")
+  entry = AGENT_REGISTRY[key]
+  return nil unless entry.is_a?(Hash)
+
+  entry["cli_provider"]
+end
+
+# Detect CLI provider override from inline [cli:X] tag or Fizzy card tags.
+# Returns the provider name (e.g. "grok") or nil.
+def detect_cli_provider(text: "", tags: [])
+  # Inline tag: [cli:grok]
+  if (match = text.match(/\[cli:(\w+)\]/i))
+    return match[1].downcase
   end
 
-  DEFAULT_PROJECT.merge(provider_config).merge(project_config)
+  # Fizzy card tags: cli-grok
+  tags.each do |tag|
+    name = (tag.is_a?(Hash) ? tag["name"] : tag).to_s.downcase
+    return name.sub("cli-", "") if name.start_with?("cli-")
+  end
+
+  nil
 end
 
 # Copy gitignored files matching .worktreeinclude patterns from repo to worktree.
@@ -502,13 +559,17 @@ rescue StandardError => e
 end
 
 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)
-  resolved = resolve_project_cli_config(project_config)
+              source: nil, source_context: {}, skip_column_move: false, cli_provider: nil, resume: false)
+  resolved = resolve_project_cli_config(project_config, cli_provider_override: cli_provider, agent_name: agent_name)
   chdir ||= resolved["repo_path"]
   model ||= resolved["agent_model"]
   effort ||= resolved["agent_effort"]
   agent_config_name = agent_name&.downcase&.gsub(/[^a-z0-9-]/, "-")
 
+  # Auto-resume: if the provider supports session resume and we're in a worktree
+  # that has had a previous session, resume it. Only applies to follow-ups (not first dispatch).
+  should_resume = resume && resolved["resume_flag"]
+
   ensure_fizzy_yaml!(chdir, project_config)
   Thread.new { scrub_invalid_attachments!(chdir) }
 
@@ -517,24 +578,22 @@ 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)
+  cmd = build_agent_cmd(resolved, agent_config_name: agent_config_name, model: model, effort: effort, prompt_file: prompt_file, resume: should_resume)
+  prompt_mode = resolved["prompt_mode"] || "stdin"
+
   spawn_env = agent_env_for(agent_name)
 
   LOG.info "Running #{resolved["agent_cli"]} in #{chdir}, logging to #{log_file}"
   LOG.info "Prompt written to #{prompt_file}"
-  LOG.info "Command: #{cmd.join(" ")}"
+  LOG.info "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?
 
-  head_before = nil
   project_key_for_restart = PROJECTS.find { |_k, v| v == project_config }&.first
-  if project_key_for_restart == "brainiac"
-    head_before, = Open3.capture2("git", "rev-parse", "HEAD", chdir: chdir)
-    head_before = head_before.strip
-  end
+  head_before, status_before = capture_git_state(chdir) if project_key_for_restart == "brainiac"
 
   pid = spawn(spawn_env, *cmd,
               chdir: chdir,
-              in: prompt_file,
+              **(prompt_mode == "stdin" ? { in: prompt_file } : {}),
               out: [log_file, "w"],
               err: %i[child out])
 
@@ -546,7 +605,8 @@ 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,
-      head_before: head_before, project_key_for_restart: project_key_for_restart
+      head_before: head_before, status_before: status_before,
+      project_key_for_restart: project_key_for_restart
     )
   end
 
@@ -578,13 +638,28 @@ def write_agent_prompt_file(prompt, log_name, timestamp)
 end
 
 # Build the CLI command array for an agent invocation.
-def build_agent_cmd(resolved, agent_config_name: nil, model: nil, effort: nil)
+# 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)
   cmd = [resolved["agent_cli"]]
-  cmd.push("--agent", agent_config_name) if agent_config_name
+  # 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)
-  add_trust_tools!(cmd, resolved["agent_cli_args"])
-  cmd.push(resolved["agent_model_flag"], model) if resolved["agent_model_flag"] && !resolved["agent_model_flag"].empty? && model
+  # 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.6") or the key itself is mapped
+    is_known = allowed.value?(model) || allowed.key?(model)
+    cmd.push(resolved["agent_model_flag"], 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"]
+  # 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"]
   cmd
 end
 
@@ -621,7 +696,7 @@ def handle_agent_completion(**ctx)
   end
 
   brain_push(message: "#{ctx[:agent_config_name] || "agent"}: #{ctx[:log_name]}")
-  check_brainiac_restart(ctx[:head_before], ctx[:chdir], ctx[:project_key_for_restart], ctx[:agent_config_name])
+  check_brainiac_restart(ctx[:head_before], ctx[:status_before], ctx[:chdir], ctx[:project_key_for_restart], ctx[:agent_config_name])
 end
 
 def handle_fizzy_post_session(fizzy_card, exit_status, signaled, agent_name, chdir, source, source_context, project_config, skip_column_move)
@@ -672,12 +747,21 @@ def handle_plan_finalization(prompt_file, agent_name, project_config)
   end
 end
 
-def check_brainiac_restart(head_before, chdir, project_key_for_restart, agent_config_name)
+# Capture git HEAD and working tree status for a directory.
+# Returns [head_sha, status_porcelain] or [nil, nil] on failure.
+def capture_git_state(chdir)
+  head, = Open3.capture2("git", "rev-parse", "HEAD", chdir: chdir)
+  status, = Open3.capture2("git", "status", "--porcelain", chdir: chdir)
+  [head.strip, status.strip]
+rescue StandardError
+  [nil, nil]
+end
+
+def check_brainiac_restart(head_before, status_before, chdir, project_key_for_restart, agent_config_name)
   return unless project_key_for_restart == "brainiac" && head_before
 
-  head_after, = Open3.capture2("git", "rev-parse", "HEAD", chdir: chdir)
-  git_status, = Open3.capture2("git", "status", "--porcelain", chdir: chdir)
-  if head_after.strip != head_before || !git_status.strip.empty?
+  head_after, status_after = capture_git_state(chdir)
+  if head_after != head_before || status_after != (status_before || "")
     queue_brainiac_restart(agent_config_name || "agent")
   else
     LOG.info "[Brainiac] #{agent_config_name || "agent"} session on brainiac had no changes — skipping restart"