brainiac 0.0.1 → 0.0.3

data/lib/brainiac/handlers/discord.rb

@@ -32,7 +32,25 @@ DISCORD_ALL_READY_LOGGED = { done: false }
 DISCORD_SHARED_THREADS = {}
 DISCORD_SHARED_THREADS_MUTEX = Mutex.new
 
-# Zillacore restart queue: when an agent works on brainiac itself, queue a restart
+# Discord thread worktree map: tracks worktrees created for Discord thread conversations.
+# Keyed by "agent_key:channel_id" → { worktree, branch, project, created_at }
+# Persisted to disk so sessions survive restarts.
+DISCORD_THREAD_MAP_FILE = File.join(BRAINIAC_DIR, "discord_thread_map.json")
+DISCORD_THREAD_MAP_MUTEX = Mutex.new
+
+def load_discord_thread_map
+  return {} unless File.exist?(DISCORD_THREAD_MAP_FILE)
+
+  JSON.parse(File.read(DISCORD_THREAD_MAP_FILE))
+rescue JSON::ParserError
+  {}
+end
+
+def save_discord_thread_map(map)
+  File.write(DISCORD_THREAD_MAP_FILE, JSON.pretty_generate(map))
+end
+
+# Brainiac restart queue: when an agent works on brainiac itself, queue a restart
 # instead of doing it immediately. A background thread checks every 30s and only
 # restarts when no other agents are running, preventing mid-session kills.
 # Using a hash instead of a constant to allow mutation inside synchronize blocks
@@ -721,6 +739,9 @@ def handle_discord_message(message, agent_key, bot_token, bot_user_id)
   # Strip effort tag (e.g. [effort:high]) from prompt content
   clean_content_for_prompt = clean_content_for_prompt.sub(/\[effort:\w+\]/i, "").strip
 
+  # Strip CLI provider tag (e.g. [cli:grok]) from prompt content
+  clean_content_for_prompt = clean_content_for_prompt.sub(/\[cli:\w+\]/i, "").strip
+
   # Find project: inline override > channel mapping > default_project
   if inline_project_key && PROJECTS.key?(inline_project_key)
     project_key = inline_project_key
@@ -816,14 +837,37 @@ def handle_discord_message(message, agent_key, bot_token, bot_user_id)
   # Also captures root message content so the agent always has the original context.
   root_message = find_root_message(message, channel_id, bot_token)
   root_message_id = root_message[:id]
-  card_id = "discord-#{channel_id}-#{root_message_id}"
+
+  # Build a stable card_id for memory files. Inside a thread, use parent_channel + thread_id
+  # so all messages in the thread share one memory file. The thread's channel_id IS the thread
+  # starter message ID, which is stable across all messages within it.
+  card_id = if is_thread
+              "discord-#{parent_channel_id}-#{channel_id}"
+            else
+              "discord-#{channel_id}-#{root_message_id}"
+            end
 
   # Build thread root context — inject the original question/message that started
   # this thread so the agent never loses sight of it, even in long conversations.
   thread_root_context = ""
-  if is_thread && root_message[:content] && !root_message[:content].empty?
-    root_author = root_message[:author] || "unknown"
-    thread_root_context = "### Original Message (thread starter)\n#{root_author}: #{root_message[:content]}\n\n"
+  if is_thread
+    root_content = root_message[:content]
+    root_author = root_message[:author]
+
+    # Fallback: if find_root_message didn't capture content (no message_reference chain),
+    # fetch the parent message directly. In Discord, a thread's channel_id equals the
+    # message_id that the thread was created on in the parent channel.
+    if root_content.nil? || root_content.empty?
+      parent_msg = fetch_discord_message(parent_channel_id, channel_id, token: bot_token, log_errors: false)
+      if parent_msg && parent_msg["content"] && !parent_msg["content"].strip.empty?
+        root_content = parent_msg["content"].strip
+        root_author = parent_msg.dig("author", "username") || "unknown"
+      end
+    end
+
+    if root_content && !root_content.empty?
+      thread_root_context = "### Original Message (thread starter)\n#{root_author || "unknown"}: #{root_content}\n\n"
+    end
   end
 
   # Detect planning mode
@@ -836,7 +880,126 @@ def handle_discord_message(message, agent_key, bot_token, bot_user_id)
 
   brain_context = build_brain_context(agent_name: agent_name, card_title: clean_content, comment_body: clean_content)
 
-  if planning_info
+  # --- Worktree management & session resume ---
+  # Every dispatch with a project gets a dedicated worktree per agent+thread/channel.
+  # For channel messages, create a Discord thread upfront so we have a stable ID
+  # for the worktree, then dispatch in it. This ensures grok sessions persist
+  # across the thread conversation and can be resumed with -c.
+  should_resume = false
+  thread_worktree_path = nil
+  thread_cli_provider = nil
+  thread_model = nil
+  thread_effort = nil
+
+  # For channel messages (not DMs, not already in a thread), create a thread immediately
+  # so we can use its ID for the worktree. This also means the response delivery
+  # will find the pre-existing thread via the API lookup.
+  pre_created_thread_id = nil
+  if !is_thread && !is_dm && project_config
+    display_name = fizzy_display_name(agent_key)
+    thread = create_discord_thread(channel_id, message_id, name: "#{display_name}: #{clean_content[0..80]}", token: bot_token)
+    if thread && thread["id"]
+      pre_created_thread_id = thread["id"]
+      DISCORD_SHARED_THREADS_MUTEX.synchronize { DISCORD_SHARED_THREADS[message_id] = pre_created_thread_id }
+
+      # Propagate dispatch depth to the new thread
+      parent_depth_key = "discord-#{channel_id}"
+      thread_depth_key = "discord-#{pre_created_thread_id}"
+      parent_info = AGENT_DISPATCH_DEPTH[parent_depth_key]
+      if parent_info
+        AGENT_DISPATCH_DEPTH[thread_depth_key] = { count: 0, last_human_at: parent_info[:last_human_at] }
+      else
+        record_human_comment(thread_depth_key)
+      end
+
+      LOG.info "[Discord:#{agent_name}] Pre-created thread #{pre_created_thread_id} for worktree isolation"
+    else
+      LOG.warn "[Discord:#{agent_name}] Failed to pre-create thread — will run without worktree isolation"
+    end
+  end
+
+  # Determine the thread map key: use the thread ID (existing thread or pre-created one)
+  effective_thread_id = is_thread ? channel_id : pre_created_thread_id
+  thread_map_key = "#{agent_key}:#{effective_thread_id}" if effective_thread_id
+
+  if project_config && thread_map_key
+    repo_path = project_config["repo_path"]
+    thread_map = DISCORD_THREAD_MAP_MUTEX.synchronize { load_discord_thread_map }
+    existing = thread_map[thread_map_key]
+
+    if existing && existing["worktree"] && File.directory?(existing["worktree"])
+      # Existing worktree — resume session. Inherit tags from the thread's first dispatch.
+      thread_worktree_path = existing["worktree"]
+      thread_cli_provider = existing["cli_provider"]
+      thread_model = existing["model"]
+      thread_effort = existing["effort"]
+      effective_provider = detect_cli_provider(text: clean_content) || thread_cli_provider
+      resolved_for_resume = resolve_project_cli_config(project_config, cli_provider_override: effective_provider, agent_name: agent_name)
+      should_resume = resolved_for_resume["resume_flag"] ? true : false
+      LOG.info "[Discord:#{agent_name}] Reusing thread worktree at #{thread_worktree_path} (resume: #{should_resume}, cli: #{effective_provider || "default"})"
+    else
+      # First worktree creation. Inherit tags from a seeded thread map entry if present.
+      seeded_cli_provider = existing&.dig("cli_provider")
+      seeded_model = existing&.dig("model")
+      seeded_effort = existing&.dig("effort")
+
+      thread_slug = effective_thread_id[-8..]
+      branch = "discord-#{agent_key}-#{thread_slug}"
+      thread_worktree_path = File.join(File.dirname(repo_path), "#{File.basename(repo_path)}--#{branch}")
+
+      debounced_repo_fetch(repo_path)
+      default_branch = get_default_branch(repo_path)
+
+      branch_exists = system("git", "rev-parse", "--verify", branch, chdir: repo_path, out: File::NULL, err: File::NULL)
+
+      if branch_exists
+        worktree_list = run_cmd("git", "worktree", "list", "--porcelain", chdir: repo_path)
+        has_worktree = worktree_list.lines.any? { |l| l.strip == "worktree #{thread_worktree_path}" }
+        if has_worktree && File.directory?(thread_worktree_path)
+          LOG.info "[Discord:#{agent_name}] Reusing existing worktree at #{thread_worktree_path}"
+        else
+          run_cmd("git", "worktree", "add", thread_worktree_path, branch, chdir: repo_path)
+        end
+      else
+        run_cmd("git", "worktree", "add", "-b", branch, thread_worktree_path, "origin/#{default_branch}", chdir: repo_path)
+      end
+
+      trust_version_manager(thread_worktree_path, chdir: thread_worktree_path)
+      apply_worktree_includes(repo_path, thread_worktree_path)
+      run_project_hook(repo_path, "worktree-setup", extra_env: { "WORKTREE_PATH" => thread_worktree_path })
+
+      # Store tags: prefer current message tag, then seeded value from initial dispatch
+      first_cli_provider = detect_cli_provider(text: clean_content) || seeded_cli_provider
+      first_model = (project_config ? detect_model(project_config, text: clean_content) : nil) || seeded_model
+      first_effort = (project_config ? detect_effort(project_config, text: clean_content) : nil) || seeded_effort
+      thread_cli_provider = first_cli_provider
+      thread_model = first_model
+      thread_effort = first_effort
+
+      DISCORD_THREAD_MAP_MUTEX.synchronize do
+        map = load_discord_thread_map
+        map[thread_map_key] = { "worktree" => thread_worktree_path, "branch" => branch,
+                                "project" => PROJECTS.find { |_k, v| v == project_config }&.first,
+                                "channel_id" => effective_thread_id, "cli_provider" => first_cli_provider,
+                                "model" => first_model, "effort" => first_effort,
+                                "created_at" => Time.now.iso8601 }
+        save_discord_thread_map(map)
+      end
+      LOG.info "[Discord:#{agent_name}] Created thread worktree at #{thread_worktree_path}#{" (cli: #{first_cli_provider})" if first_cli_provider}#{" (model: #{first_model})" if first_model}#{" (effort: #{first_effort})" if first_effort}"
+    end
+  end
+
+  if should_resume && thread_worktree_path
+    # Lean resume prompt — prior session has full context
+    prompt = render_discord_resume_prompt(
+      message_body: clean_content_for_prompt,
+      discord_user: discord_user,
+      response_file: response_file,
+      agent_name: agent_name,
+      card_id: card_id
+    )
+    LOG.info "[Discord:#{agent_name}] Using resume prompt for thread #{channel_id}"
+  elsif planning_info
     # Planning mode — use planning prompt
     planning_card_id = planning_info[:card_id]
     LOG.info "[Discord:#{agent_name}] Planning mode detected for #{discord_user}"
@@ -875,11 +1038,46 @@ def handle_discord_message(message, agent_key, bot_token, bot_user_id)
                            channel: :discord)
   end
 
-  work_dir = project_config ? project_config["repo_path"] : Dir.pwd
+  work_dir = thread_worktree_path || (project_config ? project_config["repo_path"] : Dir.pwd)
 
   prompt_file = File.join(response_dir, "discord-prompt-#{timestamp}-#{agent_key}-#{message_id}.md")
   File.write(prompt_file, prompt)
 
+  # Detect overrides from inline tags — [opus], [effort:high], [cli:grok]
+  # Current message tags override thread defaults; thread defaults apply when no tag is present.
+  cli_provider_override = detect_cli_provider(text: clean_content) || thread_cli_provider
+
+  # For model/effort: detect_model/detect_effort return the project default when no tag matches,
+  # so we check for explicit tag presence to know whether the thread default should apply.
+  has_explicit_model = false
+  if project_config
+    allowed_models = resolve_project_cli_config(project_config)["allowed_models"] || {}
+    model_tag_match = clean_content.match(/\[(\w+)\]/i)
+    has_explicit_model = model_tag_match && allowed_models.key?(model_tag_match[1].downcase)
+  end
+  has_explicit_effort = clean_content.match?(/\[effort:\w+\]/i)
+
+  model = if has_explicit_model
+            detect_model(project_config, text: clean_content)
+          elsif thread_model
+            thread_model
+          else
+            project_config ? detect_model(project_config, text: clean_content) : nil
+          end
+
+  effort = if has_explicit_effort
+             detect_effort(project_config, text: clean_content)
+           elsif thread_effort
+             thread_effort
+           else
+             project_config ? detect_effort(project_config, text: clean_content) : nil
+           end
+
+  # Determine the "explicit" values from this message only (not thread defaults)
+  # for seeding into the thread map on initial dispatch.
+  explicit_model = has_explicit_model ? model : nil
+  explicit_effort = has_explicit_effort ? effort : nil
+
   # Write delivery metadata sidecar so the poller can post this response
   # even if the monitoring thread dies (e.g. server restart).
   meta_file = File.join(DISCORD_DRAFT_DIR, "#{response_basename}.meta.json")
@@ -891,32 +1089,35 @@ def handle_discord_message(message, agent_key, bot_token, bot_user_id)
                                                is_dm: is_dm,
                                                is_thread: is_thread,
                                                clean_content: clean_content[0..80],
+                                               cli_provider: detect_cli_provider(text: clean_content),
+                                               model: explicit_model,
+                                               effort: explicit_effort,
                                                created_at: Time.now.iso8601
                                              }))
 
-  # Detect model override — same [opus]/[sonnet]/[haiku] syntax as Fizzy comments
-  model = project_config ? detect_model(project_config, text: clean_content) : nil
-
-  # Detect effort override — [effort:high] syntax
-  effort = project_config ? detect_effort(project_config, text: clean_content) : nil
-
   agent_config_name = agent_key.downcase.gsub(/[^a-z0-9-]/, "-")
   log_file = File.join(response_dir, "discord-agent-#{timestamp}-#{agent_key}-#{message_id}.log")
 
-  resolved = project_config ? resolve_project_cli_config(project_config) : {}
+  resolved = project_config ? resolve_project_cli_config(project_config, cli_provider_override: cli_provider_override, agent_name: agent_name) : {}
   agent_cli = resolved["agent_cli"] || "kiro-cli"
   agent_cli_args = resolved["agent_cli_args"] || "chat --trust-all-tools --no-interactive"
   agent_model_flag = resolved["agent_model_flag"] || "--model"
   agent_effort_flag = resolved["agent_effort_flag"] || "--effort"
+  agent_flag = resolved.key?("agent_flag") ? resolved["agent_flag"] : "--agent"
+  prompt_mode = resolved["prompt_mode"] || "stdin"
 
   cmd = [agent_cli]
-  cmd.push("--agent", agent_config_name)
+  cmd.push(agent_flag, agent_config_name) if agent_flag
   cmd.concat(agent_cli_args.split)
-  add_trust_tools!(cmd, agent_cli_args)
-  cmd.push(agent_model_flag, model) if agent_model_flag && !agent_model_flag.empty? && model
+  if model && agent_model_flag && !agent_model_flag.empty?
+    allowed = resolved["allowed_models"] || {}
+    cmd.push(agent_model_flag, model) if allowed.value?(model) || allowed.key?(model)
+  end
   cmd.push(agent_effort_flag, effort) if agent_effort_flag && !agent_effort_flag.empty? && effort
+  cmd.push(resolved["resume_flag"]) if should_resume && resolved["resume_flag"]
+  cmd.push(resolved["prompt_flag"], prompt_file) if prompt_mode == "flag" && resolved["prompt_flag"]
 
-  LOG.info "[Discord:#{agent_name}] Dispatching for #{discord_user} (model: #{model || "default"}, effort: #{effort || "default"}), tail -f #{log_file}"
+  LOG.info "[Discord:#{agent_name}] Dispatching for #{discord_user} (model: #{model || "default"}, effort: #{effort || "default"}, cli: #{agent_cli}#{", resuming" if should_resume}), tail -f #{log_file}"
   LOG.info "[Discord:#{agent_name}] Command: #{cmd.join(" ")}"
 
   spawn_env = {}
@@ -926,19 +1127,17 @@ def handle_discord_message(message, agent_key, bot_token, bot_user_id)
     LOG.info "[Discord:#{agent_name}] Injecting #{agent_env.size} env var(s): #{agent_env.keys.join(", ")}"
   end
 
-  # Capture HEAD before spawning so we can detect if THIS session made commits
+  # Capture HEAD and dirty state before spawning so we can detect if THIS session made changes
   head_before = nil
+  status_before = nil
   if project_config
     pk = PROJECTS.find { |_k, v| v == project_config }&.first
-    if pk == "brainiac"
-      head_before, = Open3.capture2("git", "rev-parse", "HEAD", chdir: work_dir)
-      head_before = head_before.strip
-    end
+    head_before, status_before = capture_git_state(work_dir) if pk == "brainiac"
   end
 
   pid = spawn(spawn_env, *cmd,
               chdir: work_dir,
-              in: prompt_file,
+              **(prompt_mode == "stdin" ? { in: prompt_file } : {}),
               out: [log_file, "w"],
               err: %i[child out])
 
@@ -1043,14 +1242,12 @@ def handle_discord_message(message, agent_key, bot_token, bot_user_id)
     brain_push(message: "#{agent_name}: discord-#{message_id}")
 
     # Restart brainiac if THIS session actually changed code
-    # Compare HEAD now vs before the agent ran — only restart if commits were made or files are dirty
+    # Compare HEAD and dirty state now vs before — only restart if the agent made commits or new dirty files
     if project_config && head_before
       project_key = PROJECTS.find { |_k, v| v == project_config }&.first
       if project_key == "brainiac"
-        chdir = project_config["repo_path"]
-        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(project_config["repo_path"])
+        if head_after != head_before || status_after != status_before
           queue_brainiac_restart(agent_name)
         else
           LOG.info "[Brainiac] #{agent_name} Discord session on brainiac had no changes — skipping restart"
@@ -1624,10 +1821,16 @@ def start_all_discord_gateways
   end
 
   LOG.info "[Discord] Starting #{tokens.size} bot(s): #{tokens.keys.join(", ")}"
-  tokens.each do |agent_key, token|
-    DISCORD_BOTS_MUTEX.synchronize do
+
+  # Register all bots upfront so the "all ready" check sees the full set
+  # before any individual READY event fires.
+  DISCORD_BOTS_MUTEX.synchronize do
+    tokens.each do |agent_key, token|
       DISCORD_BOTS[agent_key] = { token: token, status: "starting", user_id: nil }
     end
+  end
+
+  tokens.each do |agent_key, token|
     start_discord_gateway_for(agent_key, token)
     sleep 1 # Stagger connections to avoid rate limits
   end

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