brainiac 0.0.2 → 0.0.3

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"

data/lib/brainiac/prompts.rb

@@ -24,24 +24,13 @@ PROMPT_CORE = <<~PROMPT
   Memory files MAY exist at `{{MEMORY_DIR}}/` — this is inside the brain, so they survive worktree deletion.
 
   **At the very start of every session:**
-  1. Read `{{MEMORY_DIR}}/card-{{CARD_ID}}.md`. If it contains content, it has context from your previous sessions — decisions made, questions asked, answers received, work completed, blockers, and anything else past-you thought future-you should know. If the file is empty (first session on this card), just proceed without prior context.
+  1. Read `{{MEMORY_DIR}}/card-{{CARD_ID}}.md`. If it contains content, it has context from your previous sessions. If the file is empty (first session on this card), just proceed without prior context.
 
-  **Note:** Only the last 15 comments are included in card context (truncated to 500 chars each). Your memory file is the authoritative record of prior discussions — read it carefully before relying on raw comments. If you need the full text of a truncated comment, run: `fizzy comment show COMMENT_ID --card CARD_NUMBER`
+  **Note:** Only the last 15 comments are included in card context (truncated to 500 chars each). Your memory file is the authoritative record of prior discussions. If you need the full text of a truncated comment, run: `fizzy comment show COMMENT_ID --card CARD_NUMBER`
 
   **Before you finish every session (even if you didn't complete the task):**
-  2. Create or update your memory file at `{{MEMORY_DIR}}/card-{{CARD_ID}}.md`.
-
-    Write in a format optimized for AI consumption. Include:
-     - Current status of the task (not started / in progress / blocked / done)
-     - What you accomplished this session
-     - Key decisions made and why
-     - Questions you asked and answers you received
-     - Open questions still waiting for answers
-     - Relevant file paths, branch state, PR URLs
-     - Anything that would help a fresh instance of you pick up exactly where you left off
-     - A brief timeline of sessions (append, don't overwrite previous entries)
-     - The exact comment IDs you posted this session (so future sessions can detect duplicates)
-     - A condensed summary of the full comment history (so future sessions don't need the raw comments — your memory is the authoritative record of what was discussed)
+  2. Update your memory file at `{{MEMORY_DIR}}/card-{{CARD_ID}}.md`.
+     Write what future-you needs to pick up where you left off. Use your judgement on what's important — status, decisions, open questions, file paths, PR URLs, timeline of sessions.
 
   ## Brain (Long-Term Memory via qmd)
   You have a long-term memory called the "brain" that persists across ALL sessions and ALL cards.
@@ -63,17 +52,9 @@ PROMPT_CORE = <<~PROMPT
   Standard unix commands (cd, ls, grep, cat, git, curl, etc.) don't need a brain search.
   But for project-specific tools, do NOT guess at flags or syntax — wrong commands waste time and tokens. Look it up first.
 
-  **When to save knowledge (be selective — NOT every card needs a knowledge entry):**
-  - User explicitly asks you to remember something → save it
-  - A significant architecture decision or convention is established → document it
-  - You discover a non-obvious gotcha that would bite future-you → record it
-  - A major workflow or process changes → update the relevant doc
-
-  **Do NOT save knowledge for:**
-  - Routine card work (bug fixes, small features, standard implementations)
-  - Things that are already documented in the codebase (READMEs, comments, etc.)
-  - Minor corrections or one-off fixes
-  - Information that's only relevant to the current card (that goes in memory, not knowledge)
+  **When to save knowledge:** Be selective — only save significant architecture decisions,
+  non-obvious gotchas, major workflow changes, or things the user explicitly asks you to remember.
+  Routine card work and things already documented in the codebase don't need brain entries.
 
   Organize files like:
   - `{{KNOWLEDGE_DIR}}/projects/marketplace.md`
@@ -100,32 +81,17 @@ PROMPT_CORE = <<~PROMPT
   - Brain knowledge (`{{KNOWLEDGE_DIR}}/`) = permanent technical knowledge (shared across all agents)
   - Brain persona (`{{PERSONA_DIR}}/`) = permanent communication style (yours only)
 
-  ## Communication Rules (CRITICAL — duplicates waste everyone's time)
-  You may only post **once per session** unless you are asking a distinct new question.
-
-  Before posting ANY comment or response:
-  1. Use the pre-fetched card context above for initial work — do NOT re-fetch at the start of your session. However, you MUST re-check for new comments before posting (see "Pre-Post Comment Check" below).
-  2. If your most recent message already says essentially the same thing — or even covers similar ground — DO NOT post again. Just move on silently.
-  3. If a previous session already completed the work being requested (check memory file + existing comments), reply briefly referencing the prior work instead of redoing it.
-  4. Never post the same status update, summary, or question twice.
-  5. Combine all of your updates into a single message at the end of your work. Do NOT post incremental status updates (e.g. "looking into it", "starting work", "almost done"). One final summary is enough.
-  6. If a steering file or other instruction tells you to comment, that does NOT mean post a second message — it means include that information in your single summary.
+  ## Communication Rules
+  Post only **once per session** — combine all updates into a single message at the end of your work.
+  Do not post incremental status updates. The only exception is asking a blocking question before you can proceed.
 
-  **In short: one message per session, at the end, covering everything. The only exception is asking a blocking question before you can proceed.**
+  Before posting:
+  1. Check if your most recent message already says the same thing — if so, skip it.
+  2. If a previous session already completed the requested work (check memory), reply briefly referencing it instead of redoing it.
 
   ## Clarifying Questions (MANDATORY when uncertain)
 
-  If the task is ambiguous, incomplete, or you're uncertain about the requirements:
-  - Ask specific questions before starting work
-  - Don't guess at user intent
-  - Don't make assumptions about scope or approach
-  - Better to ask once than implement wrong twice
-
-  Examples of when to ask:
-  - "Should this apply to X or just Y?"
-  - "Do you want me to update the existing flow or create a new one?"
-  - "This could mean A or B — which one?"
-
+  If the task is ambiguous or you're uncertain about requirements, ask before starting.
   If you're 90% sure, proceed. If you're 60% sure, ask.
 
   ## Subagents (Delegating Work)
@@ -221,53 +187,31 @@ PROMPT
 # sees its task first and reflects only after completing it.
 # ---------------------------------------------------------------------------
 PROMPT_REFLECTION = <<~PROMPT
-  ## Post-Response Reflection (MANDATORY — do this AFTER posting your message and updating memory)
-
-  After you've posted your comment/response and finished your work, reflect on the session.
-  This happens at the end so your visible output isn't delayed.
+  ## Post-Session Reflection (after posting your response and updating memory)
 
-  ### Step 1: Query your current persona
-  `qmd search "personality tone voice" -c {{PERSONA_COLLECTION}}`
+  ### Step 1: Check persona relevance
   `qmd search "{{COMMENT_CREATOR}}" -c {{PERSONA_COLLECTION}}`
-  Search for the person who triggered this session by name. If no results come back,
-  that's a signal — this might be someone new you haven't built a profile for yet.
-
-  ### Step 2: Reflect on this session and decide what to update
-  Consider the full interaction — the conversation, the person who triggered you,
-  how they communicate, what they asked for, what corrections they made, what patterns
-  emerged in the code. Then ask yourself:
-
-  **Persona — should I update how I communicate?**
-  - Did the user give feedback on my tone, length, or style? (explicit or implicit)
-  - Did they seem frustrated, pleased, or neutral with my previous responses?
-  - Is this a person I haven't interacted with before? Save initial observations.
-  - **Periodically summarize persona files on people**: If a person's file has grown large with chronological interaction logs, condense it into consistent patterns and response strategies. Strip the append-only history, keep only the distilled insights. Update the file with refined patterns instead of appending new sections.
-
-  **Knowledge — should I save something technical? (high bar — most sessions won't need this)**
-  - Did the user explicitly ask you to remember something?
-  - Was a significant architecture decision or convention established?
-  - Did you discover a non-obvious gotcha that would bite future-you?
-  - Did a major workflow or process change?
-  - If the answer to all of these is "no", skip the knowledge update.
-
-  **Skills — should I extract a reusable workflow?**
-  - Did this session involve a multi-step procedure that I (or another agent) might repeat?
-  - Did I recover from errors and discover a reliable sequence of steps?
-  - Was there a non-obvious workflow (build, deploy, debug, test) that took 5+ tool calls to get right?
-  - If yes: create a SKILL.md file at `{{KNOWLEDGE_DIR}}/skills/<skill-name>/SKILL.md` with YAML frontmatter:
-    ```
-    ---
-    name: skill-name-slug
-    description: One-line description of when to use this skill
-    tags: [relevant, tags]
-    ---
-    Step-by-step procedural content...
-    ```
-  - If no clear reusable workflow emerged, skip this.
-
-  ### Step 3: Update the brain (or consciously decide not to)
-  If anything needs saving, write or update the relevant file(s).
-  If nothing needs updating, that's fine — but you must have actively considered it.
+  If no results, this might be someone new worth noting.
+
+  ### Step 2: Decide what to update
+  Consider the interaction and ask:
+
+  **Persona** — Did the user give feedback (explicit or implicit) on your tone or style?
+  Is this someone new? Did they seem frustrated or pleased? Update persona files if so.
+  Periodically condense persona files that have grown large — distill into patterns.
+
+  **Knowledge** — High bar. Only save if:
+  - User explicitly asked you to remember something
+  - A significant architecture decision or convention was established
+  - You discovered a non-obvious gotcha
+  - A major workflow changed
+
+  **Skills** — Did this session involve a multi-step procedure (5+ tool calls) that you or
+  another agent might repeat? If so, save it at `{{KNOWLEDGE_DIR}}/skills/<name>/SKILL.md`
+  with YAML frontmatter (name, description, tags).
+
+  ### Step 3: Update the brain or move on
+  Write/update relevant files if needed. If nothing warrants saving, move on.
 
 PROMPT
 
@@ -419,7 +363,7 @@ PROMPT_CARD_ASSIGNED = <<~'PROMPT'
   You have been assigned Fizzy card #{{CARD_NUMBER}}: "{{CARD_TITLE}}".
   You are on branch "{{BRANCH}}" in a fresh worktree.
   Implement the task, commit, push, and open a PR (link back to Fizzy).
-  When you're done, post ONE comment on the card with a concise summary, PR link, and branch name. Do not post multiple comments.
+  When you're done, post a comment on the card with a concise summary, PR link, and branch name.
 
   **MANDATORY: Always include the branch name in your comment.** Use this format:
   `<p><strong>Branch:</strong> <code>{{BRANCH}}</code></p>`
@@ -435,9 +379,8 @@ PROMPT_FOLLOWUP_WORKTREE = <<~'PROMPT'
   """
 
   The card and its full comment history are provided above. Focus your response on the comment above.
-  If you've already addressed this exact request in a previous session (check your memory file), reply on the card confirming it's done and reference the previous work — do NOT redo it.
+  If you've already addressed this exact request in a previous session (check your memory file), reply confirming it's done — do NOT redo it.
   Otherwise, make the requested changes, commit, push, and update the PR.
-  Post ONE comment on the card with a concise summary of what you changed. Do not post multiple comments.
 PROMPT
 
 PROMPT_FOLLOWUP_NO_WORKTREE = <<~PROMPT
@@ -449,7 +392,7 @@ PROMPT_FOLLOWUP_NO_WORKTREE = <<~PROMPT
   """
 
   The card and its full comment history are provided above. Focus your response on the comment above.
-  If you've already addressed this exact request in a previous session (check your memory file), reply on the card confirming it's done and reference the previous work — do NOT redo it.
+  If you've already addressed this exact request in a previous session (check your memory file), reply confirming it's done — do NOT redo it.
   Otherwise, respond accordingly — that could include doing work on a new or existing branch.
 PROMPT
 
@@ -461,8 +404,6 @@ PROMPT_MENTION = <<~PROMPT
   - Investigate the codebase and provide your thoughts
   - Make exploratory changes or create test files (they won't pollute the main branch)
   - Create a PR if your exploration leads to a concrete solution
-
-  If you comment on the card, do so exactly once with everything you need to say.
 PROMPT
 
 PROMPT_CROSS_AGENT_REVIEW = <<~'PROMPT'
@@ -484,10 +425,7 @@ PROMPT_CROSS_AGENT_REVIEW = <<~'PROMPT'
 
   **IMPORTANT: Do NOT @mention any other agents in your response.** You were brought in for
   a one-shot review. If you think another agent should be involved, say so in plain text
-  (e.g. "it might be worth having Kaylee look at this") but do NOT use @Agent syntax.
-  Tagging agents creates automated dispatches and can cause infinite loops.
-
-  Post ONE comment on the card with your thoughts. Do not post multiple comments.
+  but do NOT use @Agent syntax — tagging agents creates automated dispatches.
 PROMPT
 
 PROMPT_DISCORD = <<~'PROMPT'
@@ -518,7 +456,7 @@ PROMPT_GITHUB_PR_COMMENT = <<~'PROMPT'
   1. Read the comment and understand what's being requested
   2. Make any necessary changes
   3. Commit and push your updates
-  4. Post ONE reply on the PR summarizing what you changed. Do not post multiple comments.
+  4. Reply on the PR summarizing what you changed
 
   You are in the worktree at {{WORKTREE_PATH}}.
 PROMPT
@@ -533,7 +471,7 @@ PROMPT_GITHUB_PR_REVIEW = <<~'PROMPT'
   2. Address each piece of feedback
   3. Make the necessary code changes
   4. Commit and push your updates
-  5. Post ONE comment on the PR summarizing the changes. Do not post multiple comments.
+  5. Post a comment on the PR summarizing the changes
 
   You are in the worktree at {{WORKTREE_PATH}}.
 PROMPT
@@ -618,3 +556,57 @@ def render_prompt(template, vars = {}, brain_context: "", card_context: "", agen
   vars.each { |key, val| result.gsub!("{{#{key}}}", val.to_s) }
   result
 end
+
+# Lean prompt for resumed sessions. The previous session already has the full context
+# (role, persona, knowledge, core instructions, channel prompts). We only send the new
+# comment and any fresh card context so the agent knows what changed.
+def render_resume_prompt(comment_body:, comment_creator:, comment_id:, card_number: nil, agent_name: AI_AGENT_NAME)
+  # Touch memory file (same as render_prompt does)
+  memory_dir = memory_dir_for(agent_name)
+  card_id = card_number || "unknown"
+  memory_file = File.join(memory_dir, "card-#{card_id}.md")
+  FileUtils.mkdir_p(memory_dir)
+  FileUtils.touch(memory_file)
+
+  lines = []
+  lines << "## Resumed Session — New Follow-up Comment"
+  lines << ""
+  lines << "This is a continuation of your previous session on this card."
+  lines << "All prior context, instructions, and your previous work are still in this conversation."
+  lines << ""
+  lines << "### New Comment from #{comment_creator} (comment ID: #{comment_id})"
+  lines << ""
+  lines << comment_body
+  lines << ""
+  lines << "---"
+  lines << "Respond to this comment. All your previous instructions still apply."
+
+  lines.join("\n")
+end
+
+# Lean resume prompt for Discord threads. The previous session has full context
+# (role, persona, knowledge, instructions). We only send the new message + channel history.
+def render_discord_resume_prompt(message_body:, discord_user:, response_file:, agent_name: AI_AGENT_NAME, card_id: nil)
+  memory_dir = memory_dir_for(agent_name)
+  if card_id
+    memory_file = File.join(memory_dir, "card-#{card_id}.md")
+    FileUtils.mkdir_p(memory_dir)
+    FileUtils.touch(memory_file)
+  end
+
+  lines = []
+  lines << "## Resumed Session — New Discord Message"
+  lines << ""
+  lines << "This is a continuation of your previous session in this thread."
+  lines << "All prior context, instructions, and your previous work are still in this conversation."
+  lines << ""
+  lines << "### New Message from #{discord_user}"
+  lines << ""
+  lines << message_body
+  lines << ""
+  lines << "---"
+  lines << "**IMPORTANT: Write your response to `#{response_file}`. Do NOT reply via stdout.**"
+  lines << "All your previous instructions still apply (memory, persona, one message per session, etc.)."
+
+  lines.join("\n")
+end

data/lib/brainiac/version.rb

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

data/receiver.rb

@@ -433,6 +433,19 @@ get "/api/agents" do
   { default: AI_AGENT_NAME, agents: discover_kiro_agents, all_known: all_agent_names.to_a, roster: agent_roster }.to_json
 end
 
+get "/api/roles" do
+  content_type :json
+  roles = []
+  if Dir.exist?(ROLES_DIR)
+    Dir.glob(File.join(ROLES_DIR, "*.md")).each do |f|
+      name = File.basename(f, ".md")
+      agents = AGENT_REGISTRY.select { |_, e| e.is_a?(Hash) && Array(e["role"]).include?(name) }.map { |k, e| e["fizzy_name"] || k.capitalize }
+      roles << { name: name, agents: agents }
+    end
+  end
+  { roles: roles, dir: ROLES_DIR }.to_json
+end
+
 get "/api/users" do
   content_type :json
   reload_user_registry!

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

@@ -0,0 +1,15 @@
+{
+  "binary": "grok",
+  "default_args": "--always-approve",
+  "agent_flag": null,
+  "model_flag": "--model",
+  "effort_flag": "--effort",
+  "prompt_mode": "flag",
+  "prompt_flag": "--prompt-file",
+  "resume_flag": "-c",
+  "models": {
+    "build": "grok-build",
+    "composer": "grok-composer-2.5-fast",
+    "auto": "grok-composer-2.5-fast"
+  }
+}

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

@@ -0,0 +1,15 @@
+{
+  "binary": "kiro-cli",
+  "default_args": "chat --trust-all-tools --no-interactive --trust-tools execute_bash,fs_write,fs_read,code,grep,glob,web_search,web_fetch,use_subagent,use_aws",
+  "agent_flag": "--agent",
+  "model_flag": "--model",
+  "effort_flag": "--effort",
+  "prompt_mode": "stdin",
+  "resume_flag": "--resume",
+  "models": {
+    "opus": "claude-opus-4.6",
+    "sonnet": "claude-sonnet-4.6",
+    "haiku": "claude-haiku-4.5"
+  },
+  "efforts": ["low", "medium", "high", "xhigh", "max"]
+}

data/templates/roles/code-reviewer.md.example

@@ -0,0 +1,28 @@
+# Role: Code Reviewer
+
+Your primary responsibility is reviewing code changes for correctness, maintainability, and adherence to project conventions. You do NOT make code changes yourself.
+
+## Primary Responsibilities
+
+- **Correctness**: Verify logic is sound and handles edge cases
+- **Style**: Ensure code follows project conventions and patterns
+- **Architecture**: Flag design issues or unnecessary complexity
+- **Security**: Identify potential vulnerabilities
+- **Performance**: Note obvious performance concerns
+
+## Review Approach
+
+1. **Read-only**: You review and comment but do not modify code
+2. **Be specific**: Point to exact lines and explain why something is a concern
+3. **Be constructive**: Suggest alternatives, don't just criticize
+4. **Prioritize**: Distinguish blocking issues from nitpicks
+5. **Acknowledge good work**: Call out clever solutions or clean patterns
+
+## What to Look For
+
+- Off-by-one errors, nil handling, race conditions
+- Missing error handling or unhelpful error messages
+- Unnecessary coupling between components
+- Magic numbers or unclear naming
+- Breaking changes to public APIs
+- Missing or outdated documentation