brainiac 0.0.31 → 0.0.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab80207a78e9cf2150459e67eae0d37fd9768a3f6aae774209099bd2b0f7fe93
-  data.tar.gz: c0af2f5a0348fa8540d575f7124218d803dee7531a6dc68205d516108314ae63
+  metadata.gz: aa14f181c9965192fcc2507837be14e29cc9bce6a0273d806dd556eb2bfb72e2
+  data.tar.gz: c1d2fcbed4ce125a150d442e4cc3a1d68dfa856c424addf981904b4b88393b70
 SHA512:
-  metadata.gz: 83451dba00ca901f85495784fcd143a5ad4fe808ea2921702805804be1bef0f26202435e6057ddfb935cbc3d3f66518eed17878ecad9123034dbd8a33bdbac28
-  data.tar.gz: 194a1c6bc7e5819cd48f3f74aeb28988e6ebcaf0681cef7ac6168497a0a487ee116ee7c78b2b7bb9a6f750743ce23c9e2d5fdc6f8cb4c6e50e4b05f2397cac55
+  metadata.gz: beaf113fb5acf361c73df0da4d93dd65a7a7159397c0b1c559e4b84df9396376148a95a7e09824744ca1d272ef51c6008da334bc906a3bd6ce8d940d0568f43a
+  data.tar.gz: 5382b695151def7319fcadfbb51ae84f6f4401b43b9de92ecd51e5c17b20a8e05723cd9943dfba4229ca70a7097f317c70f44b973e9d815f9815ee994b8414c9

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    brainiac (0.0.31)
+    brainiac (0.0.33)
       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.31)
+  brainiac (0.0.33)
   json (2.19.9) sha256=9b9025b7cdddafa38d316eca0b2358488e42d417045c1b90d216a9fefe46b79a
   language_server-protocol (3.17.0.5) sha256=fd1e39a51a28bf3eec959379985a72e296e9f9acfce46f6a79d31ca8760803cc
   lint_roller (1.1.0) sha256=2c0c845b632a7d172cb849cc90c1bce937a28c5c8ccccb50dfd46a485003cc87

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

@@ -177,6 +177,48 @@ module BeltConfig
     def ephemeral_env_for_epic(epic_number)
       "epic-#{epic_number}"
     end
+
+    # Find an active epic ephemeral env by its tracked epic branch.
+    #
+    # Epic envs are keyed by name (e.g. "epic-fp-ux") rather than a card number,
+    # and carry `epic_branch` / `epic_pr` fields. This scans the tracking file
+    # for an active entry whose `epic_branch` matches.
+    #
+    # @param branch [String] Head branch name (e.g. "epic/feature-parity-...")
+    # @return [Array(String, Hash), nil] [env_name, entry] or nil
+    def epic_env_for_branch(branch)
+      return nil if branch.nil? || branch.empty?
+
+      find_active_epic_env { |entry| entry["epic_branch"] == branch }
+    end
+
+    # Find an active epic ephemeral env by its tracked epic PR URL.
+    #
+    # @param pr_url [String] Pull request html_url
+    # @return [Array(String, Hash), nil] [env_name, entry] or nil
+    def epic_env_for_pr(pr_url)
+      return nil if pr_url.nil? || pr_url.empty?
+
+      find_active_epic_env { |entry| entry["epic_pr"] == pr_url }
+    end
+
+    private
+
+    # Scan ephemeral_envs.json for the first active epic entry matching the block.
+    # @yield [entry] each active entry hash
+    # @return [Array(String, Hash), nil] [env_name, entry] or nil
+    def find_active_epic_env
+      state_file = File.join(BRAINIAC_DIR, "ephemeral_envs.json")
+      return nil unless File.exist?(state_file)
+
+      state = JSON.parse(File.read(state_file))
+      # Returns [name, entry] for the first match, or nil.
+      state.find do |_name, entry|
+        entry.is_a?(Hash) && entry["status"] == "active" && entry["epic_branch"] && yield(entry)
+      end
+    rescue StandardError
+      nil
+    end
   end
 end
 

data/lib/brainiac/helpers.rb

@@ -32,8 +32,10 @@ def load_cli_provider(provider_name)
   config["prompt_mode"] = raw["prompt_mode"] || "stdin"
   # 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|
+  %w[prompt_flag list_models_command resume_flag resume_args resume_id_flag new_session_id_flag
+     session_list_command session_id_field session_directory_field session_updated_field
+     session_list_path session_dir output_last_message_flag cwd_flag config_override_flag
+     effort_config_key effort_map title_flag].each do |key|
     next unless raw[key]
     next if raw[key].respond_to?(:empty?) && raw[key].empty?
 
@@ -247,6 +249,67 @@ def find_work_item_by_card(card_internal_id)
   nil
 end
 
+# Find a work item by worktree path. Returns [work_item_id, info] or nil.
+# Compares realpaths so symlink worktrees still match.
+def find_work_item_by_worktree(worktree)
+  return nil unless worktree
+
+  target = path_for_compare(worktree)
+  return nil unless target
+
+  map = load_work_item_map
+  map.each do |work_item_id, info|
+    next unless info.is_a?(Hash) && info["worktree"]
+    next unless path_for_compare(info["worktree"]) == target
+
+    return [work_item_id, info]
+  end
+  nil
+end
+
+def path_for_compare(path)
+  return nil unless path
+
+  File.realpath(path)
+rescue StandardError
+  File.expand_path(path.to_s)
+end
+
+# Key used in work_item["cli_sessions"] — the CLI binary basename (e.g. "opencode").
+def cli_session_key(agent_cli)
+  return nil if agent_cli.nil? || agent_cli.to_s.empty?
+
+  File.basename(agent_cli.to_s)
+end
+
+# Stored OpenCode/CLI session id for this work item + CLI, or nil.
+def cli_session_id_for(agent_cli:, worktree: nil, work_item_id: nil)
+  key = cli_session_key(agent_cli)
+  return nil unless key
+
+  info = find_work_item_by_id(work_item_id) if work_item_id
+  info ||= find_work_item_by_worktree(worktree)&.last
+  info&.dig("cli_sessions", key)
+end
+
+# Persist a CLI session id on the work item, keyed by CLI binary name.
+# Returns true if stored, false if no matching work item.
+def update_work_item_cli_session(agent_cli:, session_id:, worktree: nil, work_item_id: nil) # rubocop:disable Naming/PredicateMethod
+  key = cli_session_key(agent_cli)
+  return false unless key && session_id && !session_id.to_s.empty?
+
+  map = load_work_item_map
+  target_id = work_item_id
+  target_id ||= find_work_item_by_worktree(worktree)&.first
+  return false unless target_id && map[target_id]
+
+  map[target_id]["cli_sessions"] ||= {}
+  map[target_id]["cli_sessions"][key] = session_id.to_s
+  save_work_item_map(map)
+  LOG.info "[WorkItem] Stored #{key} session #{session_id} on #{target_id}"
+  true
+end
+
 # Register a new work item or update an existing one.
 # Returns the work item ID.
 def register_work_item(branch:, worktree: nil, project: nil, agent: nil, source: nil, source_data: {})
@@ -561,11 +624,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 stored_cli_session_viable?(resolved, chdir) if resolved["resume_id_flag"]
   return false unless resolved["resume_flag"] || resolved["resume_args"]
 
   prior_session_exists?(chdir, resolved["agent_cli"], session_dir: resolved["session_dir"])
 end
 
+# True when this CLI resumes by session id AND the work item has a still-existing id.
+def stored_cli_session_viable?(resolved, chdir)
+  session_id = cli_session_id_for(agent_cli: resolved["agent_cli"], worktree: chdir)
+  return false if session_id.to_s.empty?
+  return true unless resolved["session_list_command"]
+
+  sessions = list_cli_sessions(resolved["session_list_command"], **session_list_fields(resolved))
+  return false unless sessions
+
+  sessions.any? { |s| s["id"] == session_id }
+end
+
 # Determine whether a session resume should actually happen.
 # Called by run_agent — plugins should NOT call this directly; pass `resume: true` to run_agent.
 #
@@ -573,8 +649,19 @@ end
 #   - :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"] || resolved["resume_args"])
+def resolve_resume(resume, resolved, chdir, session_id: nil)
+  return false unless resume
+
+  if resolved["resume_id_flag"]
+    id = session_id.to_s.empty? ? cli_session_id_for(agent_cli: resolved["agent_cli"], worktree: chdir) : session_id
+    if id.to_s.empty?
+      LOG.info "[Dispatch] Resume requested but no stored #{resolved["agent_cli"]} session for #{chdir} — starting fresh"
+      return false
+    end
+    return { "flag" => resolved["resume_id_flag"], "id" => id }
+  end
+
+  return false unless 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"]
@@ -584,6 +671,16 @@ def resolve_resume(resume, resolved, chdir)
   false
 end
 
+# Some CLIs (e.g. grok --session-id) let the caller name a new session up front.
+# Mint a UUID only on the first run, when we are not resuming an existing id.
+def mint_cli_session_id(resolved, stored_session:, resuming:)
+  return nil if resuming
+  return nil unless resolved["new_session_id_flag"]
+  return nil unless stored_session.to_s.empty?
+
+  SecureRandom.uuid
+end
+
 # Check if intent detection says to skip dispatching the agent.
 # Returns true if the message should be skipped, false otherwise.
 # Only runs if a raw message is provided, an agent is named, and intent is enabled.
@@ -619,8 +716,12 @@ def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil
   effort ||= resolved["agent_effort"]
   agent_config_name = agent_name&.downcase&.gsub(/[^a-z0-9-]/, "-")
 
+  stored_session = cli_session_id_for(agent_cli: resolved["agent_cli"], worktree: chdir)
+  work_item_id = find_work_item_by_worktree(chdir)&.first
+
   # Auto-resume: only if the provider supports it AND a prior session exists for this CLI here.
-  should_resume = resolve_resume(resume, resolved, chdir)
+  should_resume = resolve_resume(resume, resolved, chdir, session_id: stored_session)
+  minted_session_id = mint_cli_session_id(resolved, stored_session: stored_session, resuming: should_resume)
 
   # Pre-dispatch hook — plugins can prep the working directory (e.g., copy config files, clean up)
   Brainiac.emit(:pre_dispatch, chdir: chdir, project_config: project_config, agent_name: agent_name)
@@ -634,14 +735,15 @@ def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil
 
   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)
+                                  output_file: output_file, chdir: chdir, title: work_item_id,
+                                  new_session_id: minted_session_id)
   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: #{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?
+  log_agent_launch(resolved: resolved, chdir: chdir, log_file: log_file, prompt_file: prompt_file,
+                   output_file: output_file, cmd: cmd, should_resume: should_resume,
+                   spawn_env: spawn_env, agent_name: agent_name)
 
   project_key_for_restart = PROJECTS.find { |_k, v| v == project_config }&.first
   head_before, status_before = capture_git_state(chdir) if project_key_for_restart == "brainiac"
@@ -652,19 +754,16 @@ def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil
               out: [log_file, "w"],
               err: %i[child out])
 
-  Thread.new do
-    Process.wait(pid)
-    handle_agent_completion(
-      pid: pid, agent_cli: resolved["agent_cli"], agent_config_name: agent_config_name,
-      agent_name: agent_name, log_file: log_file, log_name: log_name,
-      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
-    )
-  end
+  spawn_completion_watcher(
+    pid: pid, agent_cli: resolved["agent_cli"], agent_config_name: agent_config_name,
+    agent_name: agent_name, log_file: log_file, log_name: log_name,
+    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, resolved: resolved, minted_session_id: minted_session_id,
+    head_before: head_before, status_before: status_before,
+    project_key_for_restart: project_key_for_restart
+  )
 
   LOG.info "#{resolved["agent_cli"]} started (pid: #{pid}, agent: #{agent_config_name || "default"}, " \
            "model: #{model || "default"}), tail -f #{log_file}"
@@ -672,6 +771,23 @@ def run_agent(prompt, project_config:, chdir: nil, log_name: "agent", model: nil
   [pid, log_file]
 end
 
+# Spawn a background thread that waits for the agent process to finish and runs completion handling.
+def spawn_completion_watcher(**ctx)
+  Thread.new do
+    Process.wait(ctx[:pid])
+    handle_agent_completion(**ctx)
+  end
+end
+
+# Log the details of an agent launch (command, prompt/output files, injected env).
+def log_agent_launch(resolved:, chdir:, log_file:, prompt_file:, output_file:, cmd:, should_resume:, spawn_env:, agent_name:)
+  LOG.info "Running #{resolved["agent_cli"]} in #{chdir}, logging to #{log_file}"
+  LOG.info "Prompt: #{prompt_file} | Output: #{output_file || "none"} | Command: #{cmd.join(" ")}#{" (resuming session)" if should_resume}"
+  return if spawn_env.empty?
+
+  LOG.info "Injecting #{spawn_env.size} env var(s) for agent #{agent_name}: #{spawn_env.keys.join(", ")}"
+end
+
 # Write agent prompt to a temp file, return path.
 def write_agent_prompt_file(prompt, log_name, timestamp)
   prompt_dir = File.join(BRAINIAC_DIR, "tmp")
@@ -717,7 +833,8 @@ end
 # 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)
+def build_agent_cmd(resolved, agent_config_name: nil, model: nil, effort: nil, prompt_file: nil, resume: false,
+                    output_file: nil, chdir: nil, title: nil, new_session_id: 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).
@@ -730,25 +847,44 @@ def build_agent_cmd(resolved, agent_config_name: nil, model: nil, effort: nil, p
   # 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"] || {}
-    # 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
+  append_model_to_cmd(cmd, model, resolved)
   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)
+  cmd.push(resolved["title_flag"], title) if title && resolved["title_flag"]
+  if new_session_id && resolved["new_session_id_flag"] && !(resume.is_a?(Hash) || resume.is_a?(String) || resume == :resume_args)
+    cmd.push(resolved["new_session_id_flag"], new_session_id)
+  end
+  append_resume_to_cmd(cmd, resume)
   # 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
+
+# Append the --model flag when a valid model ID is resolved for this provider.
+# "auto" means "let the CLI choose" — skip passing it unless the provider maps it.
+def append_model_to_cmd(cmd, model, resolved)
+  return unless model && resolved["agent_model_flag"] && !resolved["agent_model_flag"].empty?
+
+  allowed = resolved["allowed_models"] || {}
+  # 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
+
+# Resume via --session <id> (OpenCode), a bare flag (grok -c), or resume_args (already applied).
+def append_resume_to_cmd(cmd, resume)
+  case resume
+  when Hash
+    flag = resume["flag"] || resume[:flag]
+    id = resume["id"] || resume[:id]
+    cmd.push(flag, id) if flag && id
+  when String
+    cmd.push(resume)
+  end
+end
 # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
 # Map a Brainiac effort level through the provider's effort_map (if any).
@@ -778,23 +914,130 @@ def append_effort_to_cmd(cmd, effort, resolved)
   end
 end
 
-# Append --model flag if the model is valid for this provider.
+# Parse a CLI session list as JSON, ignoring non-JSON prefixes (e.g. mise).
+# Normalizes OpenCode `{id, directory, updated}` and kiro `{sessionId, cwd, updatedAt}`
+# (including kiro's `[{cwd, sessions: [...]}]` envelopes) into a flat array of
+# `{ "id", "directory", "updated" }` hashes. Provider JSON can override field names.
+def parse_session_list_output(output, id_field: nil, directory_field: nil, updated_field: nil, list_path: nil)
+  return nil if output.nil? || output.strip.empty?
+
+  json_start = output.index("[") || output.index("{")
+  return nil unless json_start
+
+  data = JSON.parse(output[json_start..])
+  rows = data.is_a?(Array) ? data : Array(data["sessions"] || data["data"])
+  return nil unless rows.is_a?(Array)
+
+  flatten_session_rows(rows, id_field: id_field, directory_field: directory_field,
+                             updated_field: updated_field, list_path: list_path)
+rescue JSON::ParserError
+  nil
+end
+
+def flatten_session_rows(rows, id_field: nil, directory_field: nil, updated_field: nil, list_path: nil)
+  nested_key = list_path.to_s.empty? ? "sessions" : list_path
+  fields = { id_field: id_field, directory_field: directory_field, updated_field: updated_field }
+  rows.flat_map do |row|
+    next [] unless row.is_a?(Hash)
+
+    nested = row[nested_key]
+    if nested.is_a?(Array)
+      parent_dir = session_value(row, directory_field, %w[directory dir cwd])
+      nested.filter_map { |item| normalize_session_row(item, parent_dir: parent_dir, **fields) }
+    else
+      [normalize_session_row(row, **fields)].compact
+    end
+  end
+end
+
+def normalize_session_row(row, id_field: nil, directory_field: nil, updated_field: nil, parent_dir: nil)
+  return nil unless row.is_a?(Hash)
+
+  id = session_value(row, id_field, %w[id sessionId session_id])
+  return nil if id.to_s.empty?
+
+  {
+    "id" => id.to_s,
+    "directory" => session_value(row, directory_field, %w[directory dir cwd]) || parent_dir,
+    "updated" => session_value(row, updated_field, %w[updated time_updated updatedAt updated_at]) || 0
+  }
+end
+
+def session_value(row, explicit_field, fallbacks)
+  return row[explicit_field] if explicit_field && !explicit_field.to_s.empty? && row.key?(explicit_field)
+
+  fallbacks.each { |key| return row[key] if row.key?(key) }
+  nil
+end
+
+def session_list_fields(resolved)
+  {
+    id_field: resolved["session_id_field"],
+    directory_field: resolved["session_directory_field"],
+    updated_field: resolved["session_updated_field"],
+    list_path: resolved["session_list_path"]
+  }
+end
+
+def list_cli_sessions(command, **fields)
+  stdout, stderr, status = Open3.capture3(command)
+  unless status.success?
+    LOG.warn "[Session] session_list_command failed (exit #{status.exitstatus}): #{stderr.strip}"
+    return nil
+  end
+
+  parse_session_list_output(stdout, **fields)
+end
+
+# Most recently updated session whose directory matches chdir.
+# If no session has a directory (CLI already scoped the list to cwd), pick the newest overall.
+def select_session_id_for_directory(sessions, chdir)
+  return nil if sessions.nil? || sessions.empty?
+
+  with_ids = sessions.select { |session| session.is_a?(Hash) && !session["id"].to_s.empty? }
+  return nil if with_ids.empty?
+
+  if chdir
+    target = path_for_compare(chdir)
+    matching = with_ids.select { |session| session["directory"] && path_for_compare(session["directory"]) == target }
+    with_ids = matching unless matching.empty?
+  end
+
+  newest = with_ids.max_by { |session| session["updated"] || 0 }
+  newest && newest["id"]
+end
+
+# After a run, remember the CLI session id on the work item so later dispatches
+# can pass --session/--resume-id <id> instead of continuing whichever session was last globally.
+def capture_cli_session_id(resolved:, chdir:, minted_session_id: nil)
+  if minted_session_id
+    update_work_item_cli_session(agent_cli: resolved["agent_cli"], session_id: minted_session_id, worktree: chdir)
+    return
+  end
+  return unless resolved["session_list_command"] && resolved["resume_id_flag"]
+
+  sessions = list_cli_sessions(resolved["session_list_command"], **session_list_fields(resolved))
+  session_id = select_session_id_for_directory(sessions, chdir)
+  unless session_id
+    LOG.info "[Session] No CLI session found for #{chdir}"
+    return
+  end
+
+  update_work_item_cli_session(agent_cli: resolved["agent_cli"], session_id: session_id, worktree: chdir)
+end
+
 def handle_agent_completion(**ctx)
   agent_exit_status = $CHILD_STATUS.exitstatus
   agent_signaled = $CHILD_STATUS.signaled?
   LOG.info "#{ctx[:agent_cli]} finished (pid: #{ctx[:pid]}, exit: #{agent_exit_status})"
 
-  if ctx[:source] && agent_exit_status && agent_exit_status != 0 && !agent_signaled
-    notify_agent_crash(
-      exit_status: agent_exit_status, log_file: ctx[:log_file],
-      agent_name: ctx[:agent_name], source: ctx[:source], source_context: ctx[:source_context],
-      project_config: ctx[:project_config]
-    )
-  end
+  notify_crash_if_needed(ctx, agent_exit_status, agent_signaled)
 
   # Read structured output if the provider wrote to an output file (--output-last-message).
   output_content = read_output_file(ctx[:output_file])
 
+  capture_session_id_if_possible(ctx)
+
   # 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),
@@ -813,22 +1056,49 @@ def handle_agent_completion(**ctx)
   # Clean up the output file after hook emission (content already captured above).
   FileUtils.rm_f(ctx[:output_file]) if ctx[:output_file]
 
+  run_qmd_update(ctx[:agent_config_name])
+  log_skill_candidate(ctx[:log_file])
+
+  brain_push(message: "#{ctx[:agent_config_name] || "agent"}: #{ctx[:log_name]}")
+  # check_brainiac_restart(ctx[:head_before], ctx[:status_before], ctx[:chdir], ctx[:project_key_for_restart], ctx[:agent_config_name])
+end
+
+# Capture the CLI session id after a run, if the provider and working dir are known.
+def capture_session_id_if_possible(ctx)
+  return unless ctx[:resolved] && ctx[:chdir]
+
+  capture_cli_session_id(resolved: ctx[:resolved], chdir: ctx[:chdir], minted_session_id: ctx[:minted_session_id])
+end
+
+# Notify plugins of a crashed agent session (non-zero exit, not signaled).
+def notify_crash_if_needed(ctx, agent_exit_status, agent_signaled)
+  return unless ctx[:source] && agent_exit_status && agent_exit_status != 0 && !agent_signaled
+
+  notify_agent_crash(
+    exit_status: agent_exit_status, log_file: ctx[:log_file],
+    agent_name: ctx[:agent_name], source: ctx[:source], source_context: ctx[:source_context],
+    project_config: ctx[:project_config]
+  )
+end
+
+# Run `qmd update` to reindex the brain after a session, logging the outcome.
+def run_qmd_update(agent_config_name)
   qmd_out, qmd_status = Open3.capture2e("qmd", "update")
   if qmd_status.success?
-    LOG.info "[Brain] qmd update completed after #{ctx[:agent_config_name] || "agent"} session"
+    LOG.info "[Brain] qmd update completed after #{agent_config_name || "agent"} session"
   else
     LOG.warn "[Brain] qmd update failed: #{qmd_out.strip}"
   end
+end
 
-  skill_candidate = detect_skill_candidate(ctx[:log_file])
-  if skill_candidate[:extract]
-    LOG.info "[Skills] Session qualifies for skill extraction " \
-             "(#{skill_candidate[:tool_calls]} tool calls, #{skill_candidate[:error_patterns]} error patterns) " \
-             "— agent was nudged via reflection prompt"
-  end
+# Log whether the session qualifies for skill extraction (agent nudged via reflection prompt).
+def log_skill_candidate(log_file)
+  skill_candidate = detect_skill_candidate(log_file)
+  return unless skill_candidate[:extract]
 
-  brain_push(message: "#{ctx[:agent_config_name] || "agent"}: #{ctx[:log_name]}")
-  # check_brainiac_restart(ctx[:head_before], ctx[:status_before], ctx[:chdir], ctx[:project_key_for_restart], ctx[:agent_config_name])
+  LOG.info "[Skills] Session qualifies for skill extraction " \
+           "(#{skill_candidate[:tool_calls]} tool calls, #{skill_candidate[:error_patterns]} error patterns) " \
+           "— agent was nudged via reflection prompt"
 end
 
 def check_brainiac_restart(head_before, status_before, chdir, project_key_for_restart, agent_config_name)

data/lib/brainiac/routes/api.rb

@@ -47,6 +47,54 @@ def format_recent_sessions
   end
 end
 
+# Whether a log file path is safe to serve over /api/logs.
+#
+# Agent sessions log into `<repo>/tmp` for the registered project, but most
+# real work (Fizzy cards, PR reviews, Discord agents) runs in a *worktree*
+# sibling directory named `<repo>--<suffix>` (e.g. `feature_parity--fizzy-1377-…`),
+# which is NOT under the registered repo_path. We therefore allow a log file
+# when it lives under any registered repo's `tmp/`, under any worktree sibling
+# of a registered repo (`<repo>--*/tmp/`), or under Brainiac's own `tmp/`.
+#
+# The worktree check is purely path-based (no filesystem globbing): the tmp
+# dir's grandparent directory must be a registered repo and the worktree name
+# must start with `<repo_basename>--`. This is cheap enough for the 2s log
+# poller and still matches even if the worktree was removed after the log was
+# written.
+def log_file_allowed?(log_file)
+  return true if log_allowed_repo_dirs.any? { |dir| log_file.start_with?(dir) }
+
+  log_file_in_worktree_tmp?(log_file)
+end
+
+def log_allowed_repo_dirs
+  dirs = PROJECTS.values.filter_map do |project|
+    repo_path = project["repo_path"]
+    (File.join(repo_path, "tmp") + File::SEPARATOR) if repo_path && !repo_path.empty?
+  end
+  dirs << (File.join(BRAINIAC_DIR, "tmp") + File::SEPARATOR)
+  dirs
+end
+
+# True when `log_file` sits in a `tmp/` dir of a worktree sibling of a
+# registered repo: `<parent>/<repo_basename>--<suffix>/tmp/...`.
+def log_file_in_worktree_tmp?(log_file)
+  tmp_dir = File.dirname(log_file)
+  return false unless File.basename(tmp_dir) == "tmp"
+
+  worktree = File.dirname(tmp_dir)
+  worktree_name = File.basename(worktree)
+  worktree_parent = File.dirname(worktree)
+
+  PROJECTS.values.any? do |project|
+    repo_path = project["repo_path"]
+    next false unless repo_path && !repo_path.empty?
+
+    File.dirname(repo_path) == worktree_parent &&
+      worktree_name.start_with?("#{File.basename(repo_path)}--")
+  end
+end
+
 def kill_child_process(target_pid)
   Process.kill("TERM", target_pid)
   Thread.new do
@@ -255,9 +303,7 @@ get "/api/logs" do
   halt 400, "Invalid path" if log_file.include?("..") || !log_file.start_with?("/")
   halt 404, "File not found" unless File.exist?(log_file)
 
-  allowed = PROJECTS.values.map { |p| File.join(p["repo_path"], "tmp") }
-  allowed << File.join(BRAINIAC_DIR, "tmp")
-  halt 403, "Forbidden" unless allowed.any? { |dir| log_file.start_with?(dir) }
+  halt 403, "Forbidden" unless log_file_allowed?(log_file)
 
   all_lines = File.readlines(log_file).last(lines)
   all_lines.join.gsub(/\e\[[\d;]*[a-zA-Z]/, "").gsub(/\e\[\?[\d;]*[a-zA-Z]/, "")

data/lib/brainiac/version.rb

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

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

@@ -0,0 +1,19 @@
+{
+  "binary": "opencode",
+  "default_args": "run --auto",
+  "agent_flag": null,
+  "model_flag": "--model",
+  "prompt_mode": "stdin",
+  "resume_id_flag": "--session",
+  "session_list_command": "opencode session list --format json",
+  "title_flag": "--title",
+  "list_models_command": "opencode models ollama",
+  "models": {
+    "qwen": "ollama/qwen3.6:latest",
+    "qwen36": "ollama/qwen3.6:latest",
+    "local": "ollama/qwen3.6:latest",
+    "gemma": "ollama/gemma3:12b",
+    "fast": "ollama/qwen3:4b",
+    "auto": "ollama/qwen3.6:latest"
+  }
+}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: brainiac
 version: !ruby/object:Gem::Version
-  version: 0.0.31
+  version: 0.0.33
 platform: ruby
 authors:
 - Andy Davis
@@ -166,6 +166,7 @@ files:
 - templates/cli-providers/gemini.json.example
 - templates/cli-providers/grok.json.example
 - templates/cli-providers/kiro.json.example
+- templates/cli-providers/opencode.json.example
 - templates/hooks/pre-commit
 - templates/plugins.json.example
 - templates/roles/code-reviewer.md.example