oh-my-opencode-slim 0.8.4 → 0.8.5

package/dist/index.js

@@ -3410,7 +3410,7 @@ var require_index_min = __commonJS((exports) => {
 // node_modules/which/lib/index.js
 var require_lib = __commonJS((exports, module) => {
   var { isexe, sync: isexeSync } = require_index_min();
-  var { join: join11, delimiter, sep, posix } = __require("path");
+  var { join: join9, delimiter, sep, posix } = __require("path");
   var isWindows = process.platform === "win32";
   var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
   var rRel = new RegExp(`^\\.${rSlash.source}`);
@@ -3437,7 +3437,7 @@ var require_lib = __commonJS((exports, module) => {
   var getPathPart = (raw, cmd) => {
     const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
     const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
-    return prefix + join11(pathPart, cmd);
+    return prefix + join9(pathPart, cmd);
   };
   var which = async (cmd, opt = {}) => {
     const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
@@ -3502,12 +3502,11 @@ function getCustomOpenCodeConfigDir() {
   const configDir = process.env.OPENCODE_CONFIG_DIR?.trim();
   return configDir || undefined;
 }
-function getConfigDir() {
-  const customConfigDir = getCustomOpenCodeConfigDir();
-  if (customConfigDir) {
-    return customConfigDir;
-  }
-  return getDefaultOpenCodeConfigDir();
+function getConfigSearchDirs() {
+  const dirs = [getCustomOpenCodeConfigDir(), getDefaultOpenCodeConfigDir()];
+  return dirs.filter((dir, index) => {
+    return Boolean(dir) && dirs.indexOf(dir) === index;
+  });
 }
 function getOpenCodeConfigPaths() {
   const configDir = getDefaultOpenCodeConfigDir();
@@ -3600,17 +3599,31 @@ var SUBAGENT_NAMES = [
   "librarian",
   "oracle",
   "designer",
-  "fixer"
+  "fixer",
+  "council",
+  "councillor",
+  "council-master"
 ];
 var ORCHESTRATOR_NAME = "orchestrator";
 var ALL_AGENT_NAMES = [ORCHESTRATOR_NAME, ...SUBAGENT_NAMES];
+var ORCHESTRATABLE_AGENTS = [
+  "explorer",
+  "librarian",
+  "oracle",
+  "designer",
+  "fixer",
+  "council"
+];
 var SUBAGENT_DELEGATION_RULES = {
-  orchestrator: SUBAGENT_NAMES,
+  orchestrator: ORCHESTRATABLE_AGENTS,
   fixer: [],
   designer: [],
   explorer: [],
   librarian: [],
-  oracle: []
+  oracle: [],
+  council: [],
+  councillor: [],
+  "council-master": []
 };
 var DEFAULT_MODELS = {
   orchestrator: undefined,
@@ -3618,55 +3631,21 @@ var DEFAULT_MODELS = {
   librarian: "openai/gpt-5.4-mini",
   explorer: "openai/gpt-5.4-mini",
   designer: "openai/gpt-5.4-mini",
-  fixer: "openai/gpt-5.4-mini"
+  fixer: "openai/gpt-5.4-mini",
+  council: "openai/gpt-5.4-mini",
+  councillor: "openai/gpt-5.4-mini",
+  "council-master": "openai/gpt-5.4-mini"
 };
 var POLL_INTERVAL_BACKGROUND_MS = 2000;
 var DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
 var MAX_POLL_TIME_MS = 5 * 60 * 1000;
 var FALLBACK_FAILOVER_TIMEOUT_MS = 15000;
-// src/config/loader.ts
-import * as fs from "fs";
-import * as path from "path";
-
-// src/config/agent-mcps.ts
-var DEFAULT_AGENT_MCPS = {
-  orchestrator: ["websearch"],
-  designer: [],
-  oracle: [],
-  librarian: ["websearch", "context7", "grep_app"],
-  explorer: [],
-  fixer: []
-};
-function parseList(items, allAvailable) {
-  if (!items || items.length === 0) {
-    return [];
-  }
-  const allow = items.filter((i) => !i.startsWith("!"));
-  const deny = items.filter((i) => i.startsWith("!")).map((i) => i.slice(1));
-  if (deny.includes("*")) {
-    return [];
-  }
-  if (allow.includes("*")) {
-    return allAvailable.filter((item) => !deny.includes(item));
-  }
-  return allow.filter((item) => !deny.includes(item));
-}
-function getAgentMcpList(agentName, config) {
-  const agentConfig = getAgentOverride(config, agentName);
-  if (agentConfig?.mcps !== undefined) {
-    return agentConfig.mcps;
-  }
-  const defaultMcps = DEFAULT_AGENT_MCPS[agentName];
-  return defaultMcps ?? [];
-}
-
-// src/cli/config-io.ts
-function stripJsonComments(json) {
-  const commentPattern = /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g;
-  const trailingCommaPattern = /\\"|"(?:\\"|[^"])*"|(,)(\s*[}\]])/g;
-  return json.replace(commentPattern, (match, commentGroup) => commentGroup ? "" : match).replace(trailingCommaPattern, (match, comma, closing) => comma ? closing : match);
-}
-
+var DEFAULT_MAX_SUBAGENT_DEPTH = 3;
+var PHASE_REMINDER_TEXT = `Recall Workflow Rules:
+Understand \u2192 build the best path (delegated based on Agent rules, split and parallelized as much as possible) \u2192 execute \u2192 verify.
+If delegating, launch the specialist in the same turn you mention it.`;
+var TMUX_SPAWN_DELAY_MS = 500;
+var COUNCILLOR_STAGGER_MS = 250;
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -17199,6 +17178,107 @@ function date4(params) {
 
 // node_modules/zod/v4/classic/external.js
 config(en_default());
+// src/config/council-schema.ts
+var ModelIdSchema = exports_external.string().regex(/^[^/\s]+\/[^\s]+$/, 'Expected provider/model format (e.g. "openai/gpt-5.4-mini")');
+var CouncillorConfigSchema = exports_external.object({
+  model: ModelIdSchema.describe('Model ID in provider/model format (e.g. "openai/gpt-5.4-mini")'),
+  variant: exports_external.string().optional(),
+  prompt: exports_external.string().optional().describe("Optional role/guidance injected into the councillor user prompt")
+});
+var PresetMasterOverrideSchema = exports_external.object({
+  model: ModelIdSchema.optional().describe("Override the master model for this preset"),
+  variant: exports_external.string().optional().describe("Override the master variant for this preset"),
+  prompt: exports_external.string().optional().describe("Override the master synthesis guidance for this preset")
+});
+var CouncilPresetSchema = exports_external.record(exports_external.string(), exports_external.record(exports_external.string(), exports_external.unknown())).transform((entries, ctx) => {
+  const councillors = {};
+  let masterOverride;
+  for (const [key, raw] of Object.entries(entries)) {
+    if (key === "master") {
+      const parsed = PresetMasterOverrideSchema.safeParse(raw);
+      if (!parsed.success) {
+        ctx.addIssue(`Invalid master override in preset: ${parsed.error.issues.map((i) => i.message).join(", ")}`);
+        return exports_external.NEVER;
+      }
+      masterOverride = parsed.data;
+    } else {
+      const parsed = CouncillorConfigSchema.safeParse(raw);
+      if (!parsed.success) {
+        ctx.addIssue(`Invalid councillor "${key}": ${parsed.error.issues.map((i) => i.message).join(", ")}`);
+        return exports_external.NEVER;
+      }
+      councillors[key] = parsed.data;
+    }
+  }
+  return { councillors, master: masterOverride };
+});
+var CouncilMasterConfigSchema = exports_external.object({
+  model: ModelIdSchema.describe('Model ID for the council master (e.g. "anthropic/claude-opus-4-6")'),
+  variant: exports_external.string().optional(),
+  prompt: exports_external.string().optional().describe("Optional role/guidance injected into the master synthesis prompt")
+});
+var CouncilConfigSchema = exports_external.object({
+  master: CouncilMasterConfigSchema,
+  presets: exports_external.record(exports_external.string(), CouncilPresetSchema),
+  master_timeout: exports_external.number().min(0).default(300000),
+  councillors_timeout: exports_external.number().min(0).default(180000),
+  default_preset: exports_external.string().default("default"),
+  master_fallback: exports_external.array(ModelIdSchema).optional().transform((val) => {
+    if (!val)
+      return val;
+    const unique = [...new Set(val)];
+    if (unique.length !== val.length) {
+      return unique;
+    }
+    return val;
+  }).describe("Fallback models for the council master. Tried in order if the primary model fails. " + 'Example: ["anthropic/claude-sonnet-4-6", "openai/gpt-5.4"]')
+});
+// src/config/loader.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/config/agent-mcps.ts
+var DEFAULT_AGENT_MCPS = {
+  orchestrator: ["websearch"],
+  designer: [],
+  oracle: [],
+  librarian: ["websearch", "context7", "grep_app"],
+  explorer: [],
+  fixer: [],
+  council: [],
+  councillor: [],
+  "council-master": []
+};
+function parseList(items, allAvailable) {
+  if (!items || items.length === 0) {
+    return [];
+  }
+  const allow = items.filter((i) => !i.startsWith("!"));
+  const deny = items.filter((i) => i.startsWith("!")).map((i) => i.slice(1));
+  if (deny.includes("*")) {
+    return [];
+  }
+  if (allow.includes("*")) {
+    return allAvailable.filter((item) => !deny.includes(item));
+  }
+  return allow.filter((item) => !deny.includes(item));
+}
+function getAgentMcpList(agentName, config2) {
+  const agentConfig = getAgentOverride(config2, agentName);
+  if (agentConfig?.mcps !== undefined) {
+    return agentConfig.mcps;
+  }
+  const defaultMcps = DEFAULT_AGENT_MCPS[agentName];
+  return defaultMcps ?? [];
+}
+
+// src/cli/config-io.ts
+function stripJsonComments(json2) {
+  const commentPattern = /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g;
+  const trailingCommaPattern = /\\"|"(?:\\"|[^"])*"|(,)(\s*[}\]])/g;
+  return json2.replace(commentPattern, (match, commentGroup) => commentGroup ? "" : match).replace(trailingCommaPattern, (match, comma, closing) => comma ? closing : match);
+}
+
 // src/config/schema.ts
 var ProviderModelIdSchema = exports_external.string().regex(/^[^/\s]+\/[^\s]+$/, "Expected provider/model format (provider/.../model)");
 var ManualAgentPlanSchema = exports_external.object({
@@ -17287,7 +17367,8 @@ var PluginConfigSchema = exports_external.object({
   disabled_mcps: exports_external.array(exports_external.string()).optional(),
   tmux: TmuxConfigSchema.optional(),
   background: BackgroundTaskConfigSchema.optional(),
-  fallback: FailoverConfigSchema.optional()
+  fallback: FailoverConfigSchema.optional(),
+  council: CouncilConfigSchema.optional()
 });
 
 // src/config/loader.ts
@@ -17321,6 +17402,15 @@ function findConfigPath(basePath) {
   }
   return null;
 }
+function findConfigPathInDirs(configDirs, baseName) {
+  for (const configDir of configDirs) {
+    const configPath = findConfigPath(path.join(configDir, baseName));
+    if (configPath) {
+      return configPath;
+    }
+  }
+  return null;
+}
 function deepMerge(base, override) {
   if (!base)
     return override;
@@ -17339,9 +17429,8 @@ function deepMerge(base, override) {
   return result;
 }
 function loadPluginConfig(directory) {
-  const userConfigBasePath = path.join(getConfigDir(), "oh-my-opencode-slim");
+  const userConfigPath = findConfigPathInDirs(getConfigSearchDirs(), "oh-my-opencode-slim");
   const projectConfigBasePath = path.join(directory, ".opencode", "oh-my-opencode-slim");
-  const userConfigPath = findConfigPath(userConfigBasePath);
   const projectConfigPath = findConfigPath(projectConfigBasePath);
   let config2 = userConfigPath ? loadConfigFromPath(userConfigPath) ?? {} : {};
   const projectConfig = projectConfigPath ? loadConfigFromPath(projectConfigPath) : null;
@@ -17372,8 +17461,10 @@ function loadPluginConfig(directory) {
 }
 function loadAgentPrompt(agentName, preset) {
   const presetDirName = preset && /^[a-zA-Z0-9_-]+$/.test(preset) ? preset : undefined;
-  const promptsDir = path.join(getConfigDir(), PROMPTS_DIR_NAME);
-  const promptSearchDirs = presetDirName ? [path.join(promptsDir, presetDirName), promptsDir] : [promptsDir];
+  const promptSearchDirs = getConfigSearchDirs().flatMap((configDir) => {
+    const promptsDir = path.join(configDir, PROMPTS_DIR_NAME);
+    return presetDirName ? [path.join(promptsDir, presetDirName), promptsDir] : [promptsDir];
+  });
   const result = {};
   const readFirstPrompt = (fileName, errorPrefix) => {
     for (const dir of promptSearchDirs) {
@@ -17398,6 +17489,418 @@ function getAgentOverride(config2, name) {
   const overrides = config2?.agents ?? {};
   return overrides[name] ?? overrides[Object.keys(AGENT_ALIASES).find((k) => AGENT_ALIASES[k] === name) ?? ""];
 }
+// src/utils/session.ts
+function shortModelLabel(model) {
+  return model.split("/").pop() ?? model;
+}
+function parseModelReference(model) {
+  const slashIndex = model.indexOf("/");
+  if (slashIndex <= 0 || slashIndex >= model.length - 1) {
+    return null;
+  }
+  return {
+    providerID: model.slice(0, slashIndex),
+    modelID: model.slice(slashIndex + 1)
+  };
+}
+async function promptWithTimeout(client, args, timeoutMs) {
+  if (timeoutMs <= 0) {
+    await client.session.prompt(args);
+    return;
+  }
+  const sessionId = args.path.id;
+  let timer;
+  try {
+    const promptPromise = client.session.prompt(args);
+    promptPromise.catch(() => {});
+    await Promise.race([
+      promptPromise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          client.session.abort({ path: { id: sessionId } }).catch(() => {});
+          reject(new Error(`Prompt timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function extractSessionResult(client, sessionId, options) {
+  const includeReasoning = options?.includeReasoning ?? true;
+  const messagesResult = await client.session.messages({
+    path: { id: sessionId }
+  });
+  const messages = messagesResult.data ?? [];
+  const assistantMessages = messages.filter((m) => m.info?.role === "assistant");
+  const extractedContent = [];
+  for (const message of assistantMessages) {
+    for (const part of message.parts ?? []) {
+      const allowed = includeReasoning ? part.type === "text" || part.type === "reasoning" : part.type === "text";
+      if (allowed && part.text) {
+        extractedContent.push(part.text);
+      }
+    }
+  }
+  return extractedContent.filter((t) => t.length > 0).join(`
+
+`);
+}
+
+// src/agents/orchestrator.ts
+function resolvePrompt(base, customPrompt, customAppendPrompt) {
+  if (customPrompt)
+    return customPrompt;
+  if (customAppendPrompt)
+    return `${base}
+
+${customAppendPrompt}`;
+  return base;
+}
+var ORCHESTRATOR_PROMPT = `<Role>
+You are an AI coding orchestrator that optimizes for quality, speed, cost, and reliability by delegating to specialists when it provides net efficiency gains.
+</Role>
+
+<Agents>
+
+@explorer
+- Role: Parallel search specialist for discovering unknowns across the codebase
+- Stats: 3x faster codebase search than orchestrator, 1/2 cost of orchestrator
+- Capabilities: Glob, grep, AST queries to locate files, symbols, patterns
+- **Delegate when:** Need to discover what exists before planning \u2022 Parallel searches speed discovery \u2022 Need summarized map vs full contents \u2022 Broad/uncertain scope
+- **Don't delegate when:** Know the path and need actual content \u2022 Need full file anyway \u2022 Single specific lookup \u2022 About to edit the file
+
+@librarian
+- Role: Authoritative source for current library docs and API references
+- Stats: 10x better finding up-to-date library docs than orchestrator, 1/2 cost of orchestrator
+- Capabilities: Fetches latest official docs, examples, API signatures, version-specific behavior via grep_app MCP
+- **Delegate when:** Libraries with frequent API changes (React, Next.js, AI SDKs) \u2022 Complex APIs needing official examples (ORMs, auth) \u2022 Version-specific behavior matters \u2022 Unfamiliar library \u2022 Edge cases or advanced features \u2022 Nuanced best practices
+- **Don't delegate when:** Standard usage you're confident about (\`Array.map()\`, \`fetch()\`) \u2022 Simple stable APIs \u2022 General programming knowledge \u2022 Info already in conversation \u2022 Built-in language features
+- **Rule of thumb:** "How does this library work?" \u2192 @librarian. "How does programming work?" \u2192 yourself.
+
+@oracle
+- Role: Strategic advisor for high-stakes decisions and persistent problems
+- Stats: 10x better decisions maker, problem solver, investigator than orchestrator, 0.8x speed of orchestrator, same cost.
+- Capabilities: Deep architectural reasoning, system-level trade-offs, complex debugging
+- Tools/Constraints: Slow, expensive, high-quality\u2014use sparingly when thoroughness beats speed
+- **Delegate when:** Major architectural decisions with long-term impact \u2022 Problems persisting after 2+ fix attempts \u2022 High-risk multi-system refactors \u2022 Costly trade-offs (performance vs maintainability) \u2022 Complex debugging with unclear root cause \u2022 Security/scalability/data integrity decisions \u2022 Genuinely uncertain and cost of wrong choice is high
+- **Don't delegate when:** Routine decisions you're confident about \u2022 First bug fix attempt \u2022 Straightforward trade-offs \u2022 Tactical "how" vs strategic "should" \u2022 Time-sensitive good-enough decisions \u2022 Quick research/testing can answer
+- **Rule of thumb:** Need senior architect review? \u2192 @oracle. Just do it and PR? \u2192 yourself.
+
+@designer
+- Role: UI/UX specialist for intentional, polished experiences
+- Stats: 10x better UI/UX than orchestrator
+- Capabilities: Visual direction, interactions, responsive layouts, design systems with aesthetic intent
+- **Delegate when:** User-facing interfaces needing polish \u2022 Responsive layouts \u2022 UX-critical components (forms, nav, dashboards) \u2022 Visual consistency systems \u2022 Animations/micro-interactions \u2022 Landing/marketing pages \u2022 Refining functional\u2192delightful
+- **Don't delegate when:** Backend/logic with no visual \u2022 Quick prototypes where design doesn't matter yet
+- **Rule of thumb:** Users see it and polish matters? \u2192 @designer. Headless/functional? \u2192 yourself.
+
+@fixer
+- Role: Fast execution specialist for well-defined tasks, which empowers orchestrator with parallel, speedy executions
+- Stats: 2x faster code edits, 1/2 cost of orchestrator, 0.8x quality of orchestrator
+- Tools/Constraints: Execution-focused\u2014no research, no architectural decisions
+- **Delegate when:** For implementation work, think and triage first. If the change is non-trivial or multi-file, hand bounded execution to @fixer
+- **Don't delegate when:** Needs discovery/research/decisions \u2022 Single small change (<20 lines, one file) \u2022 Unclear requirements needing iteration \u2022 Explaining to fixer > doing \u2022 Tight integration with your current work \u2022 Sequential dependencies
+- **Rule of thumb:** Explaining > doing? \u2192 yourself. Orchestrator paths selection is vastly improved by Fixer. eg it can reduce overall speed if Orchestrator splits what's usually a single task into multiple subtasks and parallelize it with fixer.
+
+@council
+- Role: Multi-LLM consensus engine for high-confidence answers
+- Stats: 3x slower than orchestrator, 3x or more cost of orchestrator
+- Capabilities: Runs multiple models in parallel, synthesizes their responses via a council master
+- **Delegate when:** Critical decisions needing diverse model perspectives \u2022 High-stakes architectural choices where consensus reduces risk \u2022 Ambiguous problems where multi-model disagreement is informative \u2022 Security-sensitive design reviews
+- **Don't delegate when:** Straightforward tasks you're confident about \u2022 Speed matters more than confidence \u2022 Single-model answer is sufficient \u2022 Routine implementation work
+- **Result handling:** Present the council's synthesized response verbatim. Do not re-summarize \u2014 the council master has already produced the final answer.
+- **Rule of thumb:** Need second/third opinions from different models? \u2192 @council. One good answer enough? \u2192 yourself.
+
+</Agents>
+
+<Workflow>
+
+## 1. Understand
+Parse request: explicit requirements + implicit needs.
+
+## 2. Path Selection
+Evaluate approach by: quality, speed, cost, reliability.
+Choose the path that optimizes all four.
+
+## 3. Delegation Check
+**STOP. Review specialists before acting.**
+
+!!! Review available agents and delegation rules. Decide whether to delegate or do it yourself. !!!
+
+**Delegation efficiency:**
+- Reference paths/lines, don't paste files (\`src/app.ts:42\` not full contents)
+- Provide context summaries, let specialists read what they need
+- Brief user on delegation goal before each call
+- Skip delegation if overhead \u2265 doing it yourself
+
+## 4. Split and Parallelize
+Can tasks be split into subtasks and run in parallel?
+- Multiple @explorer searches across different domains?
+- @explorer + @librarian research in parallel?
+- Multiple @fixer instances for faster, scoped implementation?
+
+Balance: respect dependencies, avoid parallelizing what must be sequential.
+
+## 5. Execute
+1. Break complex tasks into todos
+2. Fire parallel research/implementation
+3. Delegate to specialists or do it yourself based on step 3
+4. Integrate results
+5. Adjust if needed
+
+## 6. Verify
+- Run \`lsp_diagnostics\` for errors
+- Suggest \`simplify\` skill when applicable
+- Confirm specialists completed successfully
+- Verify solution meets requirements
+
+</Workflow>
+
+<Communication>
+
+## Clarity Over Assumptions
+- If request is vague or has multiple valid interpretations, ask a targeted question before proceeding
+- Don't guess at critical details (file paths, API choices, architectural decisions)
+- Do make reasonable assumptions for minor details and state them briefly
+
+## Concise Execution
+- Answer directly, no preamble
+- Don't summarize what you did unless asked
+- Don't explain code unless asked
+- One-word answers are fine when appropriate
+- Brief delegation notices: "Checking docs via @librarian..." not "I'm going to delegate to @librarian because..."
+
+## No Flattery
+Never: "Great question!" "Excellent idea!" "Smart choice!" or any praise of user input.
+
+## Honest Pushback
+When user's approach seems problematic:
+- State concern + alternative concisely
+- Ask if they want to proceed anyway
+- Don't lecture, don't blindly implement
+
+## Example
+**Bad:** "Great question! Let me think about the best approach here. I'm going to delegate to @librarian to check the latest Next.js documentation for the App Router, and then I'll implement the solution for you."
+
+**Good:** "Checking Next.js App Router docs via @librarian..."
+[proceeds with implementation]
+
+</Communication>
+`;
+function createOrchestratorAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = resolvePrompt(ORCHESTRATOR_PROMPT, customPrompt, customAppendPrompt);
+  const definition = {
+    name: "orchestrator",
+    description: "AI coding orchestrator that delegates tasks to specialist agents for optimal quality, speed, and cost",
+    config: {
+      temperature: 0.1,
+      prompt
+    }
+  };
+  if (Array.isArray(model)) {
+    definition._modelArray = model.map((m) => typeof m === "string" ? { id: m } : m);
+  } else if (typeof model === "string" && model) {
+    definition.config.model = model;
+  }
+  return definition;
+}
+
+// src/agents/council.ts
+var COUNCIL_AGENT_PROMPT = `You are the Council agent \u2014 a multi-LLM orchestration system that runs consensus across multiple models.
+
+**Tool**: You have access to the \`council_session\` tool.
+
+**When to use**:
+- When invoked by a user with a request
+- When you want multiple expert opinions on a complex problem
+- When higher confidence is needed through model consensus
+
+**Usage**:
+1. Call the \`council_session\` tool with the user's prompt
+2. Optionally specify a preset (default: "default")
+3. Receive the synthesized response from the council master
+4. Present the result to the user
+
+**Behavior**:
+- Delegate requests directly to council_session
+- Don't pre-analyze or filter the prompt
+- Present the synthesized result verbatim \u2014 do not re-summarize or condense
+- Briefly explain the consensus if requested`;
+function createCouncilAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = resolvePrompt(COUNCIL_AGENT_PROMPT, customPrompt, customAppendPrompt);
+  const definition = {
+    name: "council",
+    description: "Multi-LLM council agent that synthesizes responses from multiple models for higher-quality outputs",
+    config: {
+      temperature: 0.1,
+      prompt
+    }
+  };
+  if (model) {
+    definition.config.model = model;
+  }
+  return definition;
+}
+function formatCouncillorPrompt(userPrompt, councillorPrompt) {
+  if (!councillorPrompt)
+    return userPrompt;
+  return `${councillorPrompt}
+
+---
+
+${userPrompt}`;
+}
+function formatMasterSynthesisPrompt(originalPrompt, councillorResults, masterPrompt) {
+  const completedWithResults = councillorResults.filter((cr) => cr.status === "completed" && cr.result);
+  const councillorSection = completedWithResults.map((cr) => {
+    const shortModel = shortModelLabel(cr.model);
+    return `**${cr.name}** (${shortModel}):
+${cr.result}`;
+  }).join(`
+
+`);
+  const failedSection = councillorResults.filter((cr) => cr.status !== "completed").map((cr) => `**${cr.name}**: ${cr.status} \u2014 ${cr.error ?? "Unknown"}`).join(`
+`);
+  if (completedWithResults.length === 0) {
+    return `---
+
+**Original Prompt**:
+${originalPrompt}
+
+---
+
+**Councillor Responses**:
+All councillors failed to produce output. Please generate a response based on the original prompt alone.`;
+  }
+  let prompt = `---
+
+**Original Prompt**:
+${originalPrompt}
+
+---
+
+**Councillor Responses**:
+${councillorSection}`;
+  if (failedSection) {
+    prompt += `
+
+---
+
+**Failed/Timed-out Councillors**:
+${failedSection}`;
+  }
+  prompt += `
+
+---
+
+Synthesize the optimal response based on the above.`;
+  if (masterPrompt) {
+    prompt += `
+
+---
+
+**Master Guidance**:
+${masterPrompt}`;
+  }
+  return prompt;
+}
+
+// src/agents/council-master.ts
+var COUNCIL_MASTER_PROMPT = `You are the council master responsible for synthesizing responses from multiple AI models.
+
+**Role**: Review all councillor responses and create the optimal final answer.
+
+**Process**:
+1. Read the original user prompt
+2. Review each councillor's response carefully
+3. Identify the best elements from each response
+4. Resolve contradictions between councillors
+5. Synthesize a final, optimal response
+
+**Behavior**:
+- Each councillor had read-only access to the codebase \u2014 their responses may   reference specific files, functions, and line numbers
+- Clearly explain your reasoning for the chosen approach
+- Be transparent about trade-offs
+- Credit specific insights from individual councillors by name
+- If councillors disagree, explain your resolution
+- Don't just average responses \u2014 choose and improve
+
+**Output**:
+- Present the synthesized solution
+- Review, retain, and include relevant code examples, diagrams, and concrete   details from councillor responses
+- Explain your synthesis reasoning
+- Note any remaining uncertainties
+- Acknowledge if consensus was impossible`;
+function createCouncilMasterAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = resolvePrompt(COUNCIL_MASTER_PROMPT, customPrompt, customAppendPrompt);
+  return {
+    name: "council-master",
+    description: "Council synthesis engine. Receives councillor responses and produces the final answer. No tools, pure text synthesis.",
+    config: {
+      model,
+      temperature: 0.1,
+      prompt,
+      permission: {
+        "*": "deny",
+        question: "deny"
+      }
+    }
+  };
+}
+
+// src/agents/councillor.ts
+var COUNCILLOR_PROMPT = `You are a councillor in a multi-model council.
+
+**Role**: Provide your best independent analysis and solution to the given problem.
+
+**Capabilities**: You have read-only access to the codebase. You can:
+- Read files (read)
+- Search by name patterns (glob)
+- Search by content (grep)
+- Query language server (lsp_diagnostics, lsp_goto_definition, lsp_find_references)
+- Search code patterns (ast_grep_search)
+- Search external docs (if MCPs are configured for this agent)
+
+You CANNOT edit files, write files, run shell commands, or delegate to other agents. You are an advisor, not an implementer.
+
+**Behavior**:
+- **Examine the codebase** before answering \u2014 your read access is what makes   council valuable. Don't guess at code you can see.
+- Analyze the problem thoroughly
+- Provide a complete, well-reasoned response
+- Focus on the quality and correctness of your solution
+- Be direct and concise
+- Don't be influenced by what other councillors might say \u2014 you won't see   their responses
+
+**Output**:
+- Give your honest assessment
+- Reference specific files and line numbers when relevant
+- Include relevant reasoning
+- State any assumptions clearly
+- Note any uncertainties`;
+function createCouncillorAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = resolvePrompt(COUNCILLOR_PROMPT, customPrompt, customAppendPrompt);
+  return {
+    name: "councillor",
+    description: "Read-only council advisor. Examines codebase and provides independent analysis. Spawned internally by the council system.",
+    config: {
+      model,
+      temperature: 0.2,
+      prompt,
+      permission: {
+        "*": "deny",
+        question: "deny",
+        read: "allow",
+        glob: "allow",
+        grep: "allow",
+        lsp: "allow",
+        list: "allow",
+        codesearch: "allow"
+      }
+    }
+  };
+}
+
 // src/agents/designer.ts
 var DESIGNER_PROMPT = `You are a Designer - a frontend UI/UX specialist who creates intentional, polished experiences.
 
@@ -17474,19 +17977,9 @@ var EXPLORER_PROMPT = `You are Explorer - a fast codebase navigation specialist.
 
 **Role**: Quick contextual grep for codebases. Answer "Where is X?", "Find Y", "Which file has Z".
 
-**Tools Available**:
-- **grep**: Fast regex content search (powered by ripgrep). Use for text patterns, function names, strings.
-  Example: grep(pattern="function handleClick", include="*.ts")
-- **glob**: File pattern matching. Use to find files by name/extension.
-- **ast_grep_search**: AST-aware structural search (25 languages). Use for code patterns.
-  - Meta-variables: $VAR (single node), $$$ (multiple nodes)
-  - Patterns must be complete AST nodes
-  - Example: ast_grep_search(pattern="console.log($MSG)", lang="typescript")
-  - Example: ast_grep_search(pattern="async function $NAME($$$) { $$$ }", lang="javascript")
-
-**When to use which**:
+**When to use which tools**:
 - **Text/regex patterns** (strings, comments, variable names): grep
-- **Structural patterns** (function shapes, class structures): ast_grep_search  
+- **Structural patterns** (function shapes, class structures): ast_grep_search
 - **File discovery** (find by name/extension): glob
 
 **Behavior**:
@@ -17671,165 +18164,6 @@ ${customAppendPrompt}`;
   };
 }
 
-// src/agents/orchestrator.ts
-var ORCHESTRATOR_PROMPT = `<Role>
-You are an AI coding orchestrator that optimizes for quality, speed, cost, and reliability by delegating to specialists when it provides net efficiency gains.
-</Role>
-
-<Agents>
-
-@explorer
-- Role: Parallel search specialist for discovering unknowns across the codebase
-- Capabilities: Glob, grep, AST queries to locate files, symbols, patterns
-- **Delegate when:** Need to discover what exists before planning \u2022 Parallel searches speed discovery \u2022 Need summarized map vs full contents \u2022 Broad/uncertain scope
-- **Don't delegate when:** Know the path and need actual content \u2022 Need full file anyway \u2022 Single specific lookup \u2022 About to edit the file
-
-@librarian
-- Role: Authoritative source for current library docs and API references
-- Capabilities: Fetches latest official docs, examples, API signatures, version-specific behavior via grep_app MCP
-- **Delegate when:** Libraries with frequent API changes (React, Next.js, AI SDKs) \u2022 Complex APIs needing official examples (ORMs, auth) \u2022 Version-specific behavior matters \u2022 Unfamiliar library \u2022 Edge cases or advanced features \u2022 Nuanced best practices
-- **Don't delegate when:** Standard usage you're confident about (\`Array.map()\`, \`fetch()\`) \u2022 Simple stable APIs \u2022 General programming knowledge \u2022 Info already in conversation \u2022 Built-in language features
-- **Rule of thumb:** "How does this library work?" \u2192 @librarian. "How does programming work?" \u2192 yourself.
-
-@oracle
-- Role: Strategic advisor for high-stakes decisions and persistent problems
-- Capabilities: Deep architectural reasoning, system-level trade-offs, complex debugging
-- Tools/Constraints: Slow, expensive, high-quality\u2014use sparingly when thoroughness beats speed
-- **Delegate when:** Major architectural decisions with long-term impact \u2022 Problems persisting after 2+ fix attempts \u2022 High-risk multi-system refactors \u2022 Costly trade-offs (performance vs maintainability) \u2022 Complex debugging with unclear root cause \u2022 Security/scalability/data integrity decisions \u2022 Genuinely uncertain and cost of wrong choice is high
-- **Don't delegate when:** Routine decisions you're confident about \u2022 First bug fix attempt \u2022 Straightforward trade-offs \u2022 Tactical "how" vs strategic "should" \u2022 Time-sensitive good-enough decisions \u2022 Quick research/testing can answer
-- **Rule of thumb:** Need senior architect review? \u2192 @oracle. Just do it and PR? \u2192 yourself.
-
-@designer
-- Role: UI/UX specialist for intentional, polished experiences
-- Capabilities: Visual direction, interactions, responsive layouts, design systems with aesthetic intent
-- **Delegate when:** User-facing interfaces needing polish \u2022 Responsive layouts \u2022 UX-critical components (forms, nav, dashboards) \u2022 Visual consistency systems \u2022 Animations/micro-interactions \u2022 Landing/marketing pages \u2022 Refining functional\u2192delightful
-- **Don't delegate when:** Backend/logic with no visual \u2022 Quick prototypes where design doesn't matter yet
-- **Rule of thumb:** Users see it and polish matters? \u2192 @designer. Headless/functional? \u2192 yourself.
-
-@fixer
-- Role: Fast, parallel execution specialist for well-defined tasks
-- Capabilities: Efficient implementation when spec and context are clear
-- Tools/Constraints: Execution-focused\u2014no research, no architectural decisions
-- **Delegate when:** Clearly specified with known approach \u2022 3+ independent parallel tasks \u2022 Straightforward but time-consuming \u2022 Solid plan needing execution \u2022 Repetitive multi-location changes \u2022 Overhead < time saved by parallelization
-- **Don't delegate when:** Needs discovery/research/decisions \u2022 Single small change (<20 lines, one file) \u2022 Unclear requirements needing iteration \u2022 Explaining > doing \u2022 Tight integration with your current work \u2022 Sequential dependencies
-- **Parallelization:** 3+ independent tasks \u2192 spawn multiple @fixers. 1-2 simple tasks \u2192 do yourself.
-- **Rule of thumb:** Explaining > doing? \u2192 yourself. Can split to parallel streams? \u2192 multiple @fixers.
-
-</Agents>
-
-<Workflow>
-
-## 1. Understand
-Parse request: explicit requirements + implicit needs.
-
-## 2. Path Analysis
-Evaluate approach by: quality, speed, cost, reliability.
-Choose the path that optimizes all four.
-
-## 3. Delegation Check
-**STOP. Review specialists before acting.**
-
-Each specialist delivers 10x results in their domain:
-- @explorer \u2192 Parallel discovery when you need to find unknowns, not read knowns
-- @librarian \u2192 Complex/evolving APIs where docs prevent errors, not basic usage
-- @oracle \u2192 High-stakes decisions where wrong choice is costly, not routine calls
-- @designer \u2192 User-facing experiences where polish matters, not internal logic
-- @fixer \u2192 Parallel execution of clear specs, not explaining trivial changes
-
-**Delegation efficiency:**
-- Reference paths/lines, don't paste files (\`src/app.ts:42\` not full contents)
-- Provide context summaries, let specialists read what they need
-- Brief user on delegation goal before each call
-- Skip delegation if overhead \u2265 doing it yourself
-
-**Fixer parallelization:**
-- 3+ independent tasks? Spawn multiple @fixers simultaneously
-- 1-2 simple tasks? Do it yourself
-- Sequential dependencies? Handle serially or do yourself
-
-## 4. Parallelize
-Can tasks run simultaneously?
-- Multiple @explorer searches across different domains?
-- @explorer + @librarian research in parallel?
-- Multiple @fixer instances for independent changes?
-
-Balance: respect dependencies, avoid parallelizing what must be sequential.
-
-## 5. Execute
-1. Break complex tasks into todos if needed
-2. Fire parallel research/implementation
-3. Delegate to specialists or do it yourself based on step 3
-4. Integrate results
-5. Adjust if needed
-
-## 6. Verify
-- Run \`lsp_diagnostics\` for errors
-- Suggest \`simplify\` skill when applicable
-- Confirm specialists completed successfully
-- Verify solution meets requirements
-
-## Agent Role Mapping
-When a workflow calls for an **implementer** subagent: dispatch \`@fixer\`. Fixer has enforced constraints (no research, no delegation, structured output) that match the implementer role exactly.
-When a workflow calls for a **reviewer** subagent: dispatch \`@oracle\`. Oracle has the depth for architectural review and access to code review skills.
-
-</Workflow>
-
-<Communication>
-
-## Clarity Over Assumptions
-- If request is vague or has multiple valid interpretations, ask a targeted question before proceeding
-- Don't guess at critical details (file paths, API choices, architectural decisions)
-- Do make reasonable assumptions for minor details and state them briefly
-
-## Concise Execution
-- Answer directly, no preamble
-- Don't summarize what you did unless asked
-- Don't explain code unless asked
-- One-word answers are fine when appropriate
-- Brief delegation notices: "Checking docs via @librarian..." not "I'm going to delegate to @librarian because..."
-
-## No Flattery
-Never: "Great question!" "Excellent idea!" "Smart choice!" or any praise of user input.
-
-## Honest Pushback
-When user's approach seems problematic:
-- State concern + alternative concisely
-- Ask if they want to proceed anyway
-- Don't lecture, don't blindly implement
-
-## Example
-**Bad:** "Great question! Let me think about the best approach here. I'm going to delegate to @librarian to check the latest Next.js documentation for the App Router, and then I'll implement the solution for you."
-
-**Good:** "Checking Next.js App Router docs via @librarian..."
-[proceeds with implementation]
-
-</Communication>
-`;
-function createOrchestratorAgent(model, customPrompt, customAppendPrompt) {
-  let prompt = ORCHESTRATOR_PROMPT;
-  if (customPrompt) {
-    prompt = customPrompt;
-  } else if (customAppendPrompt) {
-    prompt = `${ORCHESTRATOR_PROMPT}
-
-${customAppendPrompt}`;
-  }
-  const definition = {
-    name: "orchestrator",
-    description: "AI coding orchestrator that delegates tasks to specialist agents for optimal quality, speed, and cost",
-    config: {
-      temperature: 0.1,
-      prompt
-    }
-  };
-  if (Array.isArray(model)) {
-    definition._modelArray = model.map((m) => typeof m === "string" ? { id: m } : m);
-  } else if (typeof model === "string" && model) {
-    definition.config.model = model;
-  }
-  return definition;
-}
-
 // src/agents/index.ts
 function applyOverrides(agent, override) {
   if (override.model) {
@@ -17848,9 +18182,10 @@ function applyOverrides(agent, override) {
 function applyDefaultPermissions(agent, configuredSkills) {
   const existing = agent.config.permission ?? {};
   const skillPermissions = getSkillPermissionsForAgent(agent.name, configuredSkills);
+  const questionPerm = existing.question === "deny" ? "deny" : "allow";
   agent.config.permission = {
     ...existing,
-    question: "allow",
+    question: questionPerm,
     skill: {
       ...typeof existing.skill === "object" ? existing.skill : {},
       ...skillPermissions
@@ -17865,7 +18200,10 @@ var SUBAGENT_FACTORIES = {
   librarian: createLibrarianAgent,
   oracle: createOracleAgent,
   designer: createDesignerAgent,
-  fixer: createFixerAgent
+  fixer: createFixerAgent,
+  council: createCouncilAgent,
+  councillor: createCouncillorAgent,
+  "council-master": createCouncilMasterAgent
 };
 function createAgents(config2) {
   const getModelForAgent = (name) => {
@@ -17912,7 +18250,12 @@ function getAgentConfigs(config2) {
       description: a.description,
       mcps: getAgentMcpList(a.name, config2)
     };
-    if (isSubagent(a.name)) {
+    if (a.name === "council") {
+      sdkConfig.mode = "all";
+    } else if (a.name === "councillor" || a.name === "council-master") {
+      sdkConfig.mode = "subagent";
+      sdkConfig.hidden = true;
+    } else if (isSubagent(a.name)) {
       sdkConfig.mode = "subagent";
     } else if (a.name === "orchestrator") {
       sdkConfig.mode = "primary";
@@ -18300,17 +18643,48 @@ async function extractZip(archivePath, destDir) {
     throw new Error(`zip extraction failed (exit ${exitCode}): ${stderr}`);
   }
 }
-// src/background/background-manager.ts
-function parseModelReference(model) {
-  const slashIndex = model.indexOf("/");
-  if (slashIndex <= 0 || slashIndex >= model.length - 1) {
-    return null;
+// src/background/subagent-depth.ts
+class SubagentDepthTracker {
+  depthBySession = new Map;
+  _maxDepth;
+  constructor(maxDepth = DEFAULT_MAX_SUBAGENT_DEPTH) {
+    this._maxDepth = maxDepth;
+  }
+  get maxDepth() {
+    return this._maxDepth;
+  }
+  getDepth(sessionId) {
+    return this.depthBySession.get(sessionId) ?? 0;
+  }
+  registerChild(parentSessionId, childSessionId) {
+    const parentDepth = this.getDepth(parentSessionId);
+    const childDepth = parentDepth + 1;
+    if (childDepth > this.maxDepth) {
+      log("[subagent-depth] spawn blocked: max depth exceeded", {
+        parentSessionId,
+        parentDepth,
+        childDepth,
+        maxDepth: this.maxDepth
+      });
+      return false;
+    }
+    this.depthBySession.set(childSessionId, childDepth);
+    log("[subagent-depth] child registered", {
+      parentSessionId,
+      childSessionId,
+      childDepth
+    });
+    return true;
+  }
+  cleanup(sessionId) {
+    this.depthBySession.delete(sessionId);
+  }
+  cleanupAll() {
+    this.depthBySession.clear();
   }
-  return {
-    providerID: model.slice(0, slashIndex),
-    modelID: model.slice(slashIndex + 1)
-  };
 }
+
+// src/background/background-manager.ts
 function generateTaskId() {
   return `bg_${Math.random().toString(36).substring(2, 10)}`;
 }
@@ -18319,6 +18693,7 @@ class BackgroundTaskManager {
   tasks = new Map;
   tasksBySessionId = new Map;
   agentBySessionId = new Map;
+  depthTracker;
   client;
   directory;
   tmuxEnabled;
@@ -18337,6 +18712,7 @@ class BackgroundTaskManager {
       maxConcurrentStarts: 10
     };
     this.maxConcurrentStarts = this.backgroundConfig.maxConcurrentStarts;
+    this.depthTracker = new SubagentDepthTracker;
   }
   getSubagentRules(agentName) {
     return SUBAGENT_DELEGATION_RULES[agentName] ?? ["explorer"];
@@ -18407,30 +18783,7 @@ class BackgroundTaskManager {
       seen.add(model);
       chain.push(model);
     }
-    return chain;
-  }
-  async promptWithTimeout(args, timeoutMs) {
-    if (timeoutMs <= 0) {
-      await this.client.session.prompt(args);
-      return;
-    }
-    const sessionId = args.path.id;
-    let timer;
-    try {
-      const promptPromise = this.client.session.prompt(args);
-      promptPromise.catch(() => {});
-      await Promise.race([
-        promptPromise,
-        new Promise((_, reject) => {
-          timer = setTimeout(() => {
-            this.client.session.abort({ path: { id: sessionId } }).catch(() => {});
-            reject(new Error(`Prompt timed out after ${timeoutMs}ms`));
-          }, timeoutMs);
-        })
-      ]);
-    } finally {
-      clearTimeout(timer);
-    }
+    return chain;
   }
   calculateToolPermissions(agentName) {
     const allowedSubagents = this.getSubagentRules(agentName);
@@ -18447,20 +18800,31 @@ class BackgroundTaskManager {
       return;
     }
     try {
-      const session = await this.client.session.create({
+      const parentDepth = this.depthTracker.getDepth(task.parentSessionId);
+      if (parentDepth + 1 > this.depthTracker.maxDepth) {
+        log("[background-manager] spawn blocked: max depth exceeded", {
+          parentSessionId: task.parentSessionId,
+          parentDepth,
+          maxDepth: this.depthTracker.maxDepth
+        });
+        this.completeTask(task, "failed", "Subagent depth exceeded");
+        return;
+      }
+      const session2 = await this.client.session.create({
         body: {
           parentID: task.parentSessionId,
           title: `Background: ${task.description}`
         },
         query: { directory: this.directory }
       });
-      if (!session.data?.id) {
+      if (!session2.data?.id) {
         throw new Error("Failed to create background session");
       }
-      task.sessionId = session.data.id;
-      this.tasksBySessionId.set(session.data.id, task.id);
-      this.agentBySessionId.set(session.data.id, task.agent);
+      task.sessionId = session2.data.id;
+      this.tasksBySessionId.set(session2.data.id, task.id);
+      this.agentBySessionId.set(session2.data.id, task.agent);
       task.status = "running";
+      this.depthTracker.registerChild(task.parentSessionId, session2.data.id);
       if (this.tmuxEnabled) {
         await new Promise((r) => setTimeout(r, 500));
       }
@@ -18479,7 +18843,7 @@ class BackgroundTaskManager {
       const attemptModels = chain.length > 0 ? chain : [undefined];
       const errors3 = [];
       let succeeded = false;
-      const sessionId = session.data.id;
+      const sessionId = session2.data.id;
       for (let i = 0;i < attemptModels.length; i++) {
         const model = attemptModels[i];
         const modelLabel = model ?? "default-model";
@@ -18498,7 +18862,7 @@ class BackgroundTaskManager {
           if (i > 0) {
             log(`[background-manager] fallback attempt ${i + 1}/${attemptModels.length}: ${modelLabel}`, { taskId: task.id });
           }
-          await this.promptWithTimeout({
+          await promptWithTimeout(this.client, {
             path: { id: sessionId },
             body,
             query: promptQuery
@@ -18525,7 +18889,7 @@ class BackgroundTaskManager {
         throw new Error(`All fallback models failed. ${errors3.join(" | ")}`);
       }
       log(`[background-manager] task started: ${task.id}`, {
-        sessionId: session.data.id
+        sessionId: session2.data.id
       });
     } catch (error48) {
       const errorMessage = error48 instanceof Error ? error48.message : String(error48);
@@ -18570,6 +18934,7 @@ class BackgroundTaskManager {
       task.error = "Session deleted";
       this.tasksBySessionId.delete(sessionId);
       this.agentBySessionId.delete(sessionId);
+      this.depthTracker.cleanup(sessionId);
       const resolver = this.completionResolvers.get(taskId);
       if (resolver) {
         resolver(task);
@@ -18582,22 +18947,7 @@ class BackgroundTaskManager {
     if (!task.sessionId)
       return;
     try {
-      const messagesResult = await this.client.session.messages({
-        path: { id: task.sessionId }
-      });
-      const messages = messagesResult.data ?? [];
-      const assistantMessages = messages.filter((m) => m.info?.role === "assistant");
-      const extractedContent = [];
-      for (const message of assistantMessages) {
-        for (const part of message.parts ?? []) {
-          if ((part.type === "text" || part.type === "reasoning") && part.text) {
-            extractedContent.push(part.text);
-          }
-        }
-      }
-      const responseText = extractedContent.filter((t) => t.length > 0).join(`
-
-`);
+      const responseText = await extractSessionResult(this.client, task.sessionId);
       if (responseText) {
         this.completeTask(task, "completed", responseText);
       } else {
@@ -18713,6 +19063,10 @@ class BackgroundTaskManager {
     this.tasks.clear();
     this.tasksBySessionId.clear();
     this.agentBySessionId.clear();
+    this.depthTracker.cleanupAll();
+  }
+  getDepthTracker() {
+    return this.depthTracker;
   }
 }
 // src/background/tmux-session-manager.ts
@@ -18882,6 +19236,267 @@ class TmuxSessionManager {
     log("[tmux-session-manager] cleanup complete");
   }
 }
+// src/council/council-manager.ts
+class CouncilManager {
+  client;
+  directory;
+  config;
+  depthTracker;
+  tmuxEnabled;
+  constructor(ctx, config2, depthTracker, tmuxEnabled = false) {
+    this.client = ctx.client;
+    this.directory = ctx.directory;
+    this.config = config2;
+    this.depthTracker = depthTracker;
+    this.tmuxEnabled = tmuxEnabled;
+  }
+  async runCouncil(prompt, presetName, parentSessionId) {
+    if (this.depthTracker) {
+      const parentDepth = this.depthTracker.getDepth(parentSessionId);
+      if (parentDepth + 1 > this.depthTracker.maxDepth) {
+        log("[council-manager] spawn blocked: max depth exceeded", {
+          parentSessionId,
+          parentDepth,
+          maxDepth: this.depthTracker.maxDepth
+        });
+        return {
+          success: false,
+          error: "Subagent depth exceeded",
+          councillorResults: []
+        };
+      }
+    }
+    const councilConfig = this.config?.council;
+    if (!councilConfig) {
+      log("[council-manager] Council configuration not found");
+      return {
+        success: false,
+        error: "Council not configured",
+        councillorResults: []
+      };
+    }
+    const resolvedPreset = presetName ?? councilConfig.default_preset ?? "default";
+    const preset = councilConfig.presets[resolvedPreset];
+    if (!preset) {
+      log(`[council-manager] Preset "${resolvedPreset}" not found`);
+      return {
+        success: false,
+        error: `Preset "${resolvedPreset}" not found`,
+        councillorResults: []
+      };
+    }
+    if (Object.keys(preset.councillors).length === 0) {
+      log(`[council-manager] Preset "${resolvedPreset}" has no councillors`);
+      return {
+        success: false,
+        error: `Preset "${resolvedPreset}" has no councillors configured`,
+        councillorResults: []
+      };
+    }
+    const councillorsTimeout = councilConfig.councillors_timeout ?? 180000;
+    const masterTimeout = councilConfig.master_timeout ?? 300000;
+    const councillorCount = Object.keys(preset.councillors).length;
+    log(`[council-manager] Starting council with preset "${resolvedPreset}"`, {
+      councillors: Object.keys(preset.councillors)
+    });
+    this.sendStartNotification(parentSessionId, councillorCount).catch((err) => {
+      log("[council-manager] Failed to send start notification", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+    const councillorResults = await this.runCouncillors(prompt, preset.councillors, parentSessionId, councillorsTimeout);
+    const completedCount = councillorResults.filter((r) => r.status === "completed").length;
+    log(`[council-manager] Councillors completed: ${completedCount}/${councillorResults.length}`);
+    if (completedCount === 0) {
+      return {
+        success: false,
+        error: "All councillors failed or timed out",
+        councillorResults
+      };
+    }
+    const masterResult = await this.runMaster(prompt, councillorResults, councilConfig, parentSessionId, masterTimeout, preset.master);
+    if (!masterResult.success) {
+      log("[council-manager] Master failed", {
+        error: masterResult.error
+      });
+      const bestResult = councillorResults.find((r) => r.status === "completed" && r.result);
+      return {
+        success: false,
+        error: masterResult.error ?? "Council master failed",
+        result: bestResult?.result ? `(Degraded \u2014 master failed, using ${bestResult.name}'s response)
+
+${bestResult.result}` : undefined,
+        councillorResults
+      };
+    }
+    log("[council-manager] Council completed successfully");
+    return {
+      success: true,
+      result: masterResult.result,
+      councillorResults
+    };
+  }
+  async sendStartNotification(parentSessionId, councillorCount) {
+    const message = [
+      `\u2394 Council starting \u2014 ${councillorCount} councillors launching \u2014 ctrl+x \u2193 to watch`,
+      "",
+      "[system status: continue without acknowledging this notification]"
+    ].join(`
+`);
+    await this.client.session.prompt({
+      path: { id: parentSessionId },
+      body: {
+        noReply: true,
+        parts: [{ type: "text", text: message }]
+      }
+    });
+  }
+  async runAgentSession(options) {
+    const modelRef = parseModelReference(options.model);
+    if (!modelRef) {
+      throw new Error(`Invalid model format: ${options.model}`);
+    }
+    let sessionId;
+    try {
+      const session2 = await this.client.session.create({
+        body: {
+          parentID: options.parentSessionId,
+          title: options.title
+        },
+        query: { directory: this.directory }
+      });
+      if (!session2.data?.id) {
+        throw new Error("Failed to create session");
+      }
+      sessionId = session2.data.id;
+      if (this.depthTracker) {
+        const registered = this.depthTracker.registerChild(options.parentSessionId, sessionId);
+        if (!registered) {
+          throw new Error("Subagent depth exceeded");
+        }
+      }
+      if (this.tmuxEnabled) {
+        await new Promise((r) => setTimeout(r, TMUX_SPAWN_DELAY_MS));
+      }
+      const body = {
+        agent: options.agent,
+        model: modelRef,
+        tools: { background_task: false, task: false },
+        parts: [{ type: "text", text: options.promptText }]
+      };
+      if (options.variant) {
+        body.variant = options.variant;
+      }
+      await promptWithTimeout(this.client, {
+        path: { id: sessionId },
+        body,
+        query: { directory: this.directory }
+      }, options.timeout);
+      const result = await extractSessionResult(this.client, sessionId, {
+        includeReasoning: options.includeReasoning
+      });
+      return result || "(No output)";
+    } finally {
+      if (sessionId) {
+        this.client.session.abort({ path: { id: sessionId } }).catch(() => {});
+        if (this.depthTracker) {
+          this.depthTracker.cleanup(sessionId);
+        }
+      }
+    }
+  }
+  async runCouncillors(prompt, councillors, parentSessionId, timeout) {
+    const entries = Object.entries(councillors);
+    const promises = entries.map(([name, config2], index) => (async () => {
+      if (index > 0) {
+        await new Promise((r) => setTimeout(r, index * COUNCILLOR_STAGGER_MS));
+      }
+      const modelLabel = shortModelLabel(config2.model);
+      try {
+        const result = await this.runAgentSession({
+          parentSessionId,
+          title: `Council ${name} (${modelLabel})`,
+          agent: "councillor",
+          model: config2.model,
+          promptText: formatCouncillorPrompt(prompt, config2.prompt),
+          variant: config2.variant,
+          timeout,
+          includeReasoning: false
+        });
+        return {
+          name,
+          model: config2.model,
+          status: "completed",
+          result
+        };
+      } catch (error48) {
+        const msg = error48 instanceof Error ? error48.message : String(error48);
+        return {
+          name,
+          model: config2.model,
+          status: msg.includes("timed out") ? "timed_out" : "failed",
+          error: `Councillor "${name}": ${msg}`
+        };
+      }
+    })());
+    const settled = await Promise.allSettled(promises);
+    return settled.map((result, index) => {
+      const [name, cfg] = entries[index];
+      if (result.status === "fulfilled") {
+        return {
+          name,
+          model: cfg.model,
+          status: result.value.status,
+          result: result.value.result,
+          error: result.value.error
+        };
+      }
+      return {
+        name,
+        model: cfg.model,
+        status: "failed",
+        error: result.reason instanceof Error ? result.reason.message : String(result.reason)
+      };
+    });
+  }
+  async runMaster(prompt, councillorResults, councilConfig, parentSessionId, timeout, presetMasterOverride) {
+    const masterConfig = councilConfig.master;
+    const fallbackModels = councilConfig.master_fallback ?? [];
+    const effectiveModel = presetMasterOverride?.model ?? masterConfig.model;
+    const effectiveVariant = presetMasterOverride?.variant ?? masterConfig.variant;
+    const effectivePrompt = presetMasterOverride?.prompt ?? masterConfig.prompt;
+    const attemptModels = [effectiveModel, ...fallbackModels];
+    const synthesisPrompt = formatMasterSynthesisPrompt(prompt, councillorResults, effectivePrompt);
+    const errors3 = [];
+    for (let i = 0;i < attemptModels.length; i++) {
+      const model = attemptModels[i];
+      const currentLabel = shortModelLabel(model);
+      try {
+        if (i > 0) {
+          log(`[council-manager] master fallback ${i}/${attemptModels.length - 1}: ${currentLabel}`);
+        }
+        const result = await this.runAgentSession({
+          parentSessionId,
+          title: `Council Master (${currentLabel})`,
+          agent: "council-master",
+          model,
+          promptText: synthesisPrompt,
+          variant: effectiveVariant,
+          timeout
+        });
+        return { success: true, result };
+      } catch (error48) {
+        const msg = error48 instanceof Error ? error48.message : String(error48);
+        errors3.push(`${currentLabel}: ${msg}`);
+        log(`[council-manager] master model failed: ${currentLabel} \u2014 ${msg}`);
+      }
+    }
+    return {
+      success: false,
+      error: `All master models failed. ${errors3.join(" | ")}`
+    };
+  }
+}
 // src/hooks/auto-update-checker/cache.ts
 import * as fs3 from "fs";
 import * as path4 from "path";
@@ -19558,7 +20173,10 @@ class ForegroundFallbackManager {
       const agentName = this.sessionAgent.get(sessionID);
       const chain = this.resolveChain(agentName, currentModel);
       if (!chain.length) {
-        log("[foreground-fallback] no chain configured", { sessionID, agentName });
+        log("[foreground-fallback] no chain configured", {
+          sessionID,
+          agentName
+        });
         return;
       }
       if (!this.sessionTried.has(sessionID)) {
@@ -19647,7 +20265,6 @@ var JSON_ERROR_TOOL_EXCLUDE_LIST = [
   "bash",
   "read",
   "glob",
-  "grep",
   "webfetch",
   "grep_app_searchgithub",
   "websearch_web_search_exa"
@@ -19695,9 +20312,7 @@ ${JSON_ERROR_REMINDER}`;
   };
 }
 // src/hooks/phase-reminder/index.ts
-var PHASE_REMINDER = `<reminder>Recall Workflow Rules:
-Understand \u2192 find the best path (delegate based on rules and parallelize independent work) \u2192 execute \u2192 verify.
-If delegating, launch the specialist in the same turn you mention it.</reminder>`;
+var PHASE_REMINDER = `<reminder>${PHASE_REMINDER_TEXT}</reminder>`;
 function createPhaseReminderHook() {
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
@@ -19736,15 +20351,15 @@ ${originalText}`;
     }
   };
 }
-// src/hooks/post-read-nudge/index.ts
+// src/hooks/post-file-tool-nudge/index.ts
 var NUDGE = `
 
 ---
-Workflow Reminder: delegate based on rules; If mentioning a specialist, launch it in this same turn.`;
-function createPostReadNudgeHook() {
+${PHASE_REMINDER_TEXT}`;
+function createPostFileToolNudgeHook() {
   return {
     "tool.execute.after": async (input, output) => {
-      if (input.tool !== "Read" && input.tool !== "read") {
+      if (input.tool !== "Read" && input.tool !== "read" && input.tool !== "Write" && input.tool !== "write") {
         return;
       }
       output.output = output.output + NUDGE;
@@ -32764,340 +33379,76 @@ Only cancels pending/starting/running tasks.`,
   });
   return { background_task, background_output, background_cancel };
 }
-// src/tools/grep/cli.ts
-var {spawn: spawn4 } = globalThis.Bun;
+// src/tools/council.ts
+var z3 = tool.schema;
+function formatModelComposition(councillorResults) {
+  return councillorResults.map((cr) => {
+    const shortModel = shortModelLabel(cr.model ?? "");
+    return `${cr.name}: ${shortModel}`;
+  }).join(", ");
+}
+function createCouncilTool(_ctx, councilManager) {
+  const council_session = tool({
+    description: `Launch a multi-LLM council session for consensus-based analysis.
 
-// src/tools/grep/constants.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync8 } from "fs";
-import { dirname as dirname4, join as join10 } from "path";
+Sends the prompt to multiple models (councillors) in parallel, then a council master synthesizes the best response.
 
-// src/tools/grep/downloader.ts
-import {
-  chmodSync as chmodSync2,
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync2,
-  readdirSync,
-  unlinkSync as unlinkSync2
-} from "fs";
-import { join as join9 } from "path";
-function getInstallDir() {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join9(homeDir, ".cache", "oh-my-opencode-slim", "bin");
-}
-function getRgPath() {
-  const isWindows = process.platform === "win32";
-  return join9(getInstallDir(), isWindows ? "rg.exe" : "rg");
-}
-function getInstalledRipgrepPath() {
-  const rgPath = getRgPath();
-  return existsSync7(rgPath) ? rgPath : null;
-}
+Returns the synthesized result with councillor summary.`,
+    args: {
+      prompt: z3.string().describe("The prompt to send to all councillors"),
+      preset: z3.string().optional().describe('Council preset to use (default: "default"). Must match a preset in the council config.')
+    },
+    async execute(args, toolContext) {
+      if (!toolContext || typeof toolContext !== "object" || !("sessionID" in toolContext)) {
+        throw new Error("Invalid toolContext: missing sessionID");
+      }
+      const allowedAgents = ["council", "orchestrator"];
+      const callingAgent = toolContext.agent;
+      if (callingAgent && !allowedAgents.includes(callingAgent)) {
+        throw new Error(`Council sessions can only be invoked by council or orchestrator agents. Current agent: ${callingAgent}`);
+      }
+      const prompt = String(args.prompt);
+      const preset = typeof args.preset === "string" ? args.preset : undefined;
+      const parentSessionId = toolContext.sessionID;
+      const result = await councilManager.runCouncil(prompt, preset, parentSessionId);
+      if (!result.success) {
+        if (result.result) {
+          const completed2 = result.councillorResults.filter((cr) => cr.status === "completed").length;
+          const total2 = result.councillorResults.length;
+          const composition2 = formatModelComposition(result.councillorResults);
+          return `${result.result}
 
-// src/tools/grep/constants.ts
-var cachedCli = null;
-function findExecutable(name) {
-  const isWindows = process.platform === "win32";
-  const cmd = isWindows ? "where" : "which";
-  try {
-    const result = spawnSync2(cmd, [name], { encoding: "utf-8", timeout: 5000 });
-    if (result.status === 0 && result.stdout.trim()) {
-      return result.stdout.trim().split(/\r?\n/)[0];
-    }
-  } catch {}
-  return null;
-}
-function getDataDir() {
-  if (process.platform === "win32") {
-    return process.env.LOCALAPPDATA || process.env.APPDATA || join10(process.env.USERPROFILE || ".", "AppData", "Local");
-  }
-  return process.env.XDG_DATA_HOME || join10(process.env.HOME || ".", ".local", "share");
-}
-function getOpenCodeBundledRg() {
-  const execPath = process.execPath;
-  const execDir = dirname4(execPath);
-  const isWindows = process.platform === "win32";
-  const rgName = isWindows ? "rg.exe" : "rg";
-  const candidates = [
-    join10(getDataDir(), "opencode", "bin", rgName),
-    join10(execDir, rgName),
-    join10(execDir, "bin", rgName),
-    join10(execDir, "..", "bin", rgName),
-    join10(execDir, "..", "libexec", rgName)
-  ];
-  for (const candidate of candidates) {
-    if (existsSync8(candidate)) {
-      return candidate;
-    }
-  }
-  return null;
-}
-function resolveGrepCli() {
-  if (cachedCli)
-    return cachedCli;
-  const bundledRg = getOpenCodeBundledRg();
-  if (bundledRg) {
-    cachedCli = { path: bundledRg, backend: "rg" };
-    return cachedCli;
-  }
-  const systemRg = findExecutable("rg");
-  if (systemRg) {
-    cachedCli = { path: systemRg, backend: "rg" };
-    return cachedCli;
-  }
-  const installedRg = getInstalledRipgrepPath();
-  if (installedRg) {
-    cachedCli = { path: installedRg, backend: "rg" };
-    return cachedCli;
-  }
-  const grep = findExecutable("grep");
-  if (grep) {
-    cachedCli = { path: grep, backend: "grep" };
-    return cachedCli;
-  }
-  cachedCli = { path: "rg", backend: "rg" };
-  return cachedCli;
-}
-var DEFAULT_MAX_DEPTH = 20;
-var DEFAULT_MAX_FILESIZE = "10M";
-var DEFAULT_MAX_COUNT = 500;
-var DEFAULT_MAX_COLUMNS = 1000;
-var DEFAULT_TIMEOUT_MS3 = 300000;
-var DEFAULT_MAX_OUTPUT_BYTES2 = 10 * 1024 * 1024;
-var RG_SAFETY_FLAGS = [
-  "--no-follow",
-  "--color=never",
-  "--no-heading",
-  "--line-number",
-  "--with-filename"
-];
-var GREP_SAFETY_FLAGS = ["-n", "-H", "--color=never"];
+---
+*Council: ${completed2}/${total2} councillors responded (${composition2}) \u2014 degraded*`;
+        }
+        return `Council session failed: ${result.error}`;
+      }
+      let output = result.result ?? "(No output)";
+      const completed = result.councillorResults.filter((cr) => cr.status === "completed").length;
+      const total = result.councillorResults.length;
+      const composition = formatModelComposition(result.councillorResults);
+      output += `
 
-// src/tools/grep/cli.ts
-function buildRgArgs(options) {
-  const args = [
-    ...RG_SAFETY_FLAGS,
-    `--max-depth=${Math.min(options.maxDepth ?? DEFAULT_MAX_DEPTH, DEFAULT_MAX_DEPTH)}`,
-    `--max-filesize=${options.maxFilesize ?? DEFAULT_MAX_FILESIZE}`,
-    `--max-count=${Math.min(options.maxCount ?? DEFAULT_MAX_COUNT, DEFAULT_MAX_COUNT)}`,
-    `--max-columns=${Math.min(options.maxColumns ?? DEFAULT_MAX_COLUMNS, DEFAULT_MAX_COLUMNS)}`
-  ];
-  if (options.context !== undefined && options.context > 0) {
-    args.push(`-C${Math.min(options.context, 10)}`);
-  }
-  if (options.caseSensitive) {
-    args.push("--case-sensitive");
-  } else {
-    args.push("-i");
-  }
-  if (options.wholeWord)
-    args.push("-w");
-  if (options.fixedStrings)
-    args.push("-F");
-  if (options.multiline)
-    args.push("-U");
-  if (options.hidden)
-    args.push("--hidden");
-  if (options.noIgnore)
-    args.push("--no-ignore");
-  if (options.fileType?.length) {
-    for (const type of options.fileType) {
-      args.push(`--type=${type}`);
-    }
-  }
-  if (options.globs) {
-    for (const glob of options.globs) {
-      args.push(`--glob=${glob}`);
-    }
-  }
-  if (options.excludeGlobs) {
-    for (const glob of options.excludeGlobs) {
-      args.push(`--glob=!${glob}`);
-    }
-  }
-  return args;
-}
-function buildGrepArgs(options) {
-  const args = [...GREP_SAFETY_FLAGS, "-r"];
-  if (options.context !== undefined && options.context > 0) {
-    args.push(`-C${Math.min(options.context, 10)}`);
-  }
-  if (!options.caseSensitive)
-    args.push("-i");
-  if (options.wholeWord)
-    args.push("-w");
-  if (options.fixedStrings)
-    args.push("-F");
-  if (options.globs?.length) {
-    for (const glob of options.globs) {
-      args.push(`--include=${glob}`);
-    }
-  }
-  if (options.excludeGlobs?.length) {
-    for (const glob of options.excludeGlobs) {
-      args.push(`--exclude=${glob}`);
-    }
-  }
-  args.push("--exclude-dir=.git", "--exclude-dir=node_modules");
-  return args;
-}
-function buildArgs(options, backend) {
-  return backend === "rg" ? buildRgArgs(options) : buildGrepArgs(options);
-}
-function parseOutput(output) {
-  if (!output.trim())
-    return [];
-  const matches = [];
-  const lines = output.trim().split(/\r?\n/);
-  for (const line of lines) {
-    if (!line.trim())
-      continue;
-    const match = line.match(/^(.+?):(\d+):(.*)$/);
-    if (match) {
-      matches.push({
-        file: match[1],
-        line: parseInt(match[2], 10),
-        text: match[3]
-      });
+---
+*Council: ${completed}/${total} councillors responded (${composition})*`;
+      return output;
     }
-  }
-  return matches;
-}
-async function runRg(options) {
-  const cli = resolveGrepCli();
-  const args = buildArgs(options, cli.backend);
-  const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS3, DEFAULT_TIMEOUT_MS3);
-  if (cli.backend === "rg") {
-    args.push("--", options.pattern);
-  } else {
-    args.push("-e", options.pattern);
-  }
-  const paths2 = options.paths?.length ? options.paths : ["."];
-  args.push(...paths2);
-  const proc = spawn4([cli.path, ...args], {
-    stdout: "pipe",
-    stderr: "pipe"
   });
-  const timeoutPromise = new Promise((_, reject) => {
-    const id = setTimeout(() => {
-      proc.kill();
-      reject(new Error(`Search timeout after ${timeout}ms`));
-    }, timeout);
-    proc.exited.then(() => clearTimeout(id));
-  });
-  try {
-    const stdout = await Promise.race([
-      new Response(proc.stdout).text(),
-      timeoutPromise
-    ]);
-    const stderr = await new Response(proc.stderr).text();
-    const exitCode = await proc.exited;
-    const truncated = stdout.length >= DEFAULT_MAX_OUTPUT_BYTES2;
-    const outputToProcess = truncated ? stdout.substring(0, DEFAULT_MAX_OUTPUT_BYTES2) : stdout;
-    if (exitCode > 1 && stderr.trim()) {
-      return {
-        matches: [],
-        totalMatches: 0,
-        filesSearched: 0,
-        truncated: false,
-        error: stderr.trim()
-      };
-    }
-    const matches = parseOutput(outputToProcess);
-    const filesSearched = new Set(matches.map((m) => m.file)).size;
-    return {
-      matches,
-      totalMatches: matches.length,
-      filesSearched,
-      truncated
-    };
-  } catch (e) {
-    return {
-      matches: [],
-      totalMatches: 0,
-      filesSearched: 0,
-      truncated: false,
-      error: e instanceof Error ? e.message : String(e)
-    };
-  }
-}
-// src/tools/grep/utils.ts
-function formatGrepResult(result) {
-  if (result.error) {
-    return `Error: ${result.error}`;
-  }
-  if (result.matches.length === 0) {
-    return "No matches found.";
-  }
-  const lines = [];
-  const byFile = new Map;
-  for (const match of result.matches) {
-    const existing = byFile.get(match.file) || [];
-    existing.push({ line: match.line, text: match.text });
-    byFile.set(match.file, existing);
-  }
-  for (const [file3, matches] of byFile) {
-    lines.push(`
-${file3}:`);
-    for (const match of matches) {
-      lines.push(`  ${match.line}: ${match.text}`);
-    }
-  }
-  const summary = `Found ${result.totalMatches} matches in ${result.filesSearched} files`;
-  if (result.truncated) {
-    lines.push(`
-${summary} (output truncated)`);
-  } else {
-    lines.push(`
-${summary}`);
-  }
-  return lines.join(`
-`);
+  return { council_session };
 }
-
-// src/tools/grep/tools.ts
-var grep = tool({
-  description: "Fast content search tool with safety limits (60s timeout, 10MB output). " + "Searches file contents using regular expressions. " + 'Supports full regex syntax (eg. "log.*Error", "function\\s+\\w+", etc.). ' + 'Filter files by pattern with the include parameter (e.g. "*.js", "*.{ts,tsx}"). ' + "Returns file paths with matches sorted by modification time.",
-  args: {
-    pattern: tool.schema.string().describe("The regex pattern to search for in file contents"),
-    include: tool.schema.string().optional().describe('File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")'),
-    path: tool.schema.string().optional().describe("The directory to search in. Defaults to the current working directory."),
-    caseSensitive: tool.schema.boolean().optional().default(false).describe("Perform case-sensitive search (default: false)"),
-    wholeWord: tool.schema.boolean().optional().default(false).describe("Match whole words only (default: false)"),
-    fixedStrings: tool.schema.boolean().optional().default(false).describe("Treat pattern as literal string (default: false)")
-  },
-  execute: async (args) => {
-    try {
-      const globs = args.include ? [args.include] : undefined;
-      const paths2 = args.path ? [args.path] : undefined;
-      const result = await runRg({
-        pattern: args.pattern,
-        paths: paths2,
-        globs,
-        context: 0,
-        caseSensitive: args.caseSensitive ?? false,
-        wholeWord: args.wholeWord ?? false,
-        fixedStrings: args.fixedStrings ?? false
-      });
-      return formatGrepResult(result);
-    } catch (e) {
-      return `Error: ${e instanceof Error ? e.message : String(e)}`;
-    }
-  }
-});
 // src/tools/lsp/client.ts
 var import_node = __toESM(require_main(), 1);
 import { readFileSync as readFileSync4 } from "fs";
 import { extname, resolve as resolve2 } from "path";
 import { Readable, Writable } from "stream";
 import { pathToFileURL } from "url";
-var {spawn: spawn5 } = globalThis.Bun;
+var {spawn: spawn4 } = globalThis.Bun;
 
 // src/tools/lsp/config.ts
 var import_which = __toESM(require_lib(), 1);
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join11 } from "path";
+import { join as join9 } from "path";
 
 // src/tools/lsp/config-store.ts
 var userConfig = new Map;
@@ -33127,8 +33478,8 @@ function hasUserLspConfig() {
 }
 
 // src/tools/lsp/constants.ts
-import { existsSync as existsSync9, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
-import { dirname as dirname5, resolve } from "path";
+import { existsSync as existsSync7, readdirSync, statSync as statSync3 } from "fs";
+import { dirname as dirname4, resolve } from "path";
 var SEVERITY_MAP = {
   1: "error",
   2: "warning",
@@ -33148,10 +33499,10 @@ function* walkUpDirectories(start, stop) {
   let dir = resolve(start);
   try {
     if (!statSync3(dir).isDirectory()) {
-      dir = dirname5(dir);
+      dir = dirname4(dir);
     }
   } catch {
-    dir = dirname5(dir);
+    dir = dirname4(dir);
   }
   let prevDir = "";
   while (dir !== prevDir && dir !== "/") {
@@ -33159,7 +33510,7 @@ function* walkUpDirectories(start, stop) {
     prevDir = dir;
     if (dir === stop)
       break;
-    dir = dirname5(dir);
+    dir = dirname4(dir);
   }
 }
 function NearestRoot(includePatterns, excludePatterns) {
@@ -33168,7 +33519,7 @@ function NearestRoot(includePatterns, excludePatterns) {
     if (excludePatterns) {
       for (const dir of walkUpDirectories(file3, cwd)) {
         for (const pattern of excludePatterns) {
-          if (existsSync9(`${dir}/${pattern}`)) {
+          if (existsSync7(`${dir}/${pattern}`)) {
             return;
           }
         }
@@ -33178,13 +33529,13 @@ function NearestRoot(includePatterns, excludePatterns) {
       for (const pattern of includePatterns) {
         if (pattern.includes("*")) {
           try {
-            const entries = readdirSync2(dir);
+            const entries = readdirSync(dir);
             const regex = new RegExp(`^${pattern.replace(/\./g, "\\.").replace(/\*/g, ".*")}$`);
             if (entries.some((entry) => regex.test(entry))) {
               return dir;
             }
           } catch {}
-        } else if (existsSync9(`${dir}/${pattern}`)) {
+        } else if (existsSync7(`${dir}/${pattern}`)) {
           return dir;
         }
       }
@@ -33732,11 +34083,11 @@ function isServerInstalled(command) {
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    return existsSync10(cmd);
+    return existsSync8(cmd);
   }
   const isWindows = process.platform === "win32";
   const ext = isWindows ? ".exe" : "";
-  const opencodeBin = join11(homedir4(), ".config", "opencode", "bin");
+  const opencodeBin = join9(homedir4(), ".config", "opencode", "bin");
   const searchPath = (process.env.PATH ?? "") + (isWindows ? ";" : ":") + opencodeBin;
   const result = import_which.default.sync(cmd, {
     path: searchPath,
@@ -33747,8 +34098,8 @@ function isServerInstalled(command) {
     return true;
   }
   const cwd = process.cwd();
-  const localBin = join11(cwd, "node_modules", ".bin", cmd);
-  if (existsSync10(localBin) || existsSync10(localBin + ext)) {
+  const localBin = join9(cwd, "node_modules", ".bin", cmd);
+  if (existsSync8(localBin) || existsSync8(localBin + ext)) {
     return true;
   }
   return false;
@@ -33929,7 +34280,7 @@ class LSPClient {
       command: this.server.command.join(" "),
       root: this.root
     });
-    this.proc = spawn5(this.server.command, {
+    this.proc = spawn4(this.server.command, {
       stdin: "pipe",
       stdout: "pipe",
       stderr: "pipe",
@@ -34161,19 +34512,19 @@ stderr: ${stderr}` : ""));
 }
 // src/tools/lsp/utils.ts
 import {
-  existsSync as existsSync11,
+  existsSync as existsSync9,
   readFileSync as readFileSync5,
   statSync as statSync4,
-  unlinkSync as unlinkSync3,
+  unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync3
 } from "fs";
-import { dirname as dirname6, extname as extname2, join as join12, resolve as resolve3 } from "path";
+import { dirname as dirname5, extname as extname2, join as join10, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function findServerProjectRoot(filePath, server) {
   if (server.root) {
-    return server.root(filePath) ?? dirname6(resolve3(filePath));
+    return server.root(filePath) ?? dirname5(resolve3(filePath));
   }
-  return dirname6(resolve3(filePath));
+  return dirname5(resolve3(filePath));
 }
 function uriToPath(uri) {
   return fileURLToPath2(uri);
@@ -34203,7 +34554,7 @@ async function withLspClient(filePath, fn) {
     throw new Error(formatServerLookupError(result));
   }
   const server = result.server;
-  const root = findServerProjectRoot(absPath, server) ?? dirname6(absPath);
+  const root = findServerProjectRoot(absPath, server) ?? dirname5(absPath);
   log("[lsp] withLspClient: acquiring client", {
     filePath: absPath,
     server: server.id,
@@ -34358,7 +34709,7 @@ function applyWorkspaceEdit(edit) {
             const newPath = uriToPath(change.newUri);
             const content = readFileSync5(oldPath, "utf-8");
             writeFileSync3(newPath, content, "utf-8");
-            unlinkSync3(oldPath);
+            unlinkSync2(oldPath);
             result.filesModified.push(newPath);
           } catch (err) {
             result.success = false;
@@ -34367,7 +34718,7 @@ function applyWorkspaceEdit(edit) {
         } else if (change.kind === "delete") {
           try {
             const filePath = uriToPath(change.uri);
-            unlinkSync3(filePath);
+            unlinkSync2(filePath);
             result.filesModified.push(filePath);
           } catch (err) {
             result.success = false;
@@ -34578,6 +34929,7 @@ var OhMyOpenCodeLite = async (ctx) => {
   }
   const backgroundManager = new BackgroundTaskManager(ctx, tmuxConfig, config3);
   const backgroundTools = createBackgroundTools(ctx, backgroundManager, tmuxConfig, config3);
+  const councilTools = config3.council ? createCouncilTool(ctx, new CouncilManager(ctx, config3, backgroundManager.getDepthTracker(), tmuxConfig.enabled)) : {};
   const mcps = createBuiltinMcps(config3.disabled_mcps);
   const tmuxSessionManager = new TmuxSessionManager(ctx, tmuxConfig);
   const autoUpdateChecker = createAutoUpdateCheckerHook(ctx, {
@@ -34585,7 +34937,7 @@ var OhMyOpenCodeLite = async (ctx) => {
     autoUpdate: true
   });
   const phaseReminderHook = createPhaseReminderHook();
-  const postReadNudgeHook = createPostReadNudgeHook();
+  const postFileToolNudgeHook = createPostFileToolNudgeHook();
   const chatHeadersHook = createChatHeadersHook(ctx);
   const delegateTaskRetryHook = createDelegateTaskRetryHook(ctx);
   const jsonErrorRecoveryHook = createJsonErrorRecoveryHook(ctx);
@@ -34595,11 +34947,11 @@ var OhMyOpenCodeLite = async (ctx) => {
     agent: agents,
     tool: {
       ...backgroundTools,
+      ...councilTools,
       lsp_goto_definition,
       lsp_find_references,
       lsp_diagnostics,
       lsp_rename,
-      grep,
       ast_grep_search,
       ast_grep_replace
     },
@@ -34651,52 +35003,22 @@ var OhMyOpenCodeLite = async (ctx) => {
         }
       }
       if (Object.keys(effectiveArrays).length > 0) {
-        const providerConfig = opencodeConfig.provider ?? {};
-        const hasProviderConfig = Object.keys(providerConfig).length > 0;
         for (const [agentName, modelArray] of Object.entries(effectiveArrays)) {
           if (modelArray.length === 0)
             continue;
-          let resolved = false;
-          if (hasProviderConfig) {
-            const configuredProviders = Object.keys(providerConfig);
-            for (const modelEntry of modelArray) {
-              const slashIdx = modelEntry.id.indexOf("/");
-              if (slashIdx === -1)
-                continue;
-              const providerID = modelEntry.id.slice(0, slashIdx);
-              if (configuredProviders.includes(providerID)) {
-                const entry = configAgent[agentName];
-                if (entry) {
-                  entry.model = modelEntry.id;
-                  if (modelEntry.variant) {
-                    entry.variant = modelEntry.variant;
-                  }
-                }
-                log("[plugin] resolved model fallback", {
-                  agent: agentName,
-                  model: modelEntry.id,
-                  variant: modelEntry.variant
-                });
-                resolved = true;
-                break;
-              }
-            }
-          }
-          if (!resolved) {
-            const firstModel = modelArray[0];
-            const entry = configAgent[agentName];
-            if (entry) {
-              entry.model = firstModel.id;
-              if (firstModel.variant) {
-                entry.variant = firstModel.variant;
-              }
+          const chosen = modelArray[0];
+          const entry = configAgent[agentName];
+          if (entry) {
+            entry.model = chosen.id;
+            if (chosen.variant) {
+              entry.variant = chosen.variant;
             }
-            log("[plugin] resolved model from array (no provider config)", {
-              agent: agentName,
-              model: firstModel.id,
-              variant: firstModel.variant
-            });
           }
+          log("[plugin] resolved model from array", {
+            agent: agentName,
+            model: chosen.id,
+            variant: chosen.variant
+          });
         }
       }
       const configMcp = opencodeConfig.mcp;
@@ -34741,7 +35063,7 @@ var OhMyOpenCodeLite = async (ctx) => {
     "tool.execute.after": async (input, output) => {
       await delegateTaskRetryHook["tool.execute.after"](input, output);
       await jsonErrorRecoveryHook["tool.execute.after"](input, output);
-      await postReadNudgeHook["tool.execute.after"](input, output);
+      await postFileToolNudgeHook["tool.execute.after"](input, output);
     }
   };
 };