@kimbho/kimbho-cli 0.1.3 → 0.1.5

package/dist/index.cjs

@@ -1147,7 +1147,7 @@ var require_command = __commonJS({
   "../../node_modules/commander/lib/command.js"(exports2) {
     var EventEmitter = require("node:events").EventEmitter;
     var childProcess = require("node:child_process");
-    var path6 = require("node:path");
+    var path7 = require("node:path");
     var fs = require("node:fs");
     var process12 = require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -2147,9 +2147,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path6.resolve(baseDir, baseName);
+          const localBin = path7.resolve(baseDir, baseName);
           if (fs.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path6.extname(baseName))) return void 0;
+          if (sourceExt.includes(path7.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext) => fs.existsSync(`${localBin}${ext}`)
           );
@@ -2167,17 +2167,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path6.resolve(
-            path6.dirname(resolvedScriptPath),
+          executableDir = path7.resolve(
+            path7.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path6.basename(
+            const legacyName = path7.basename(
               this._scriptPath,
-              path6.extname(this._scriptPath)
+              path7.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2188,7 +2188,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path6.extname(executableFile));
+        launchWithNode = sourceExt.includes(path7.extname(executableFile));
         let proc;
         if (process12.platform !== "win32") {
           if (launchWithNode) {
@@ -3035,7 +3035,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path6.basename(filename, path6.extname(filename));
+        this._name = path7.basename(filename, path7.extname(filename));
         return this;
       }
       /**
@@ -3049,9 +3049,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path7) {
-        if (path7 === void 0) return this._executableDir;
-        this._executableDir = path7;
+      executableDir(path8) {
+        if (path8 === void 0) return this._executableDir;
+        this._executableDir = path8;
         return this;
       }
       /**
@@ -3346,7 +3346,7 @@ var {
 // package.json
 var package_default = {
   name: "@kimbho/kimbho-cli",
-  version: "0.1.3",
+  version: "0.1.5",
   description: "Kimbho CLI is a terminal-native coding agent for planning, execution, and verification.",
   type: "module",
   engines: {
@@ -3414,9 +3414,12 @@ var AGENT_CATALOG = {
     brainRole: "fast",
     purpose: "Map the workspace, commands, conventions, and likely risk areas before implementation.",
     defaultTools: [
+      "file.list",
+      "file.search",
       "file.read",
       "shell.exec",
-      "git.status"
+      "git.status",
+      "git.diff"
     ],
     escalationTriggers: [
       "Unknown build entry points",
@@ -3429,6 +3432,8 @@ var AGENT_CATALOG = {
     brainRole: "planner",
     purpose: "Generate machine-readable plans, milestone graphs, and re-plan when reality changes.",
     defaultTools: [
+      "file.list",
+      "file.search",
       "file.read"
     ],
     escalationTriggers: [
@@ -3442,9 +3447,12 @@ var AGENT_CATALOG = {
     brainRole: "fast",
     purpose: "Select the next ready tasks, assign them to specialists, and supervise completion.",
     defaultTools: [
+      "file.list",
+      "file.search",
       "file.read",
       "shell.exec",
-      "tests.run"
+      "tests.run",
+      "git.diff"
     ],
     escalationTriggers: [
       "Blocked dependency chains",
@@ -3457,8 +3465,12 @@ var AGENT_CATALOG = {
     brainRole: "coder",
     purpose: "Implement and refine user-facing flows and integration points.",
     defaultTools: [
+      "file.list",
+      "file.search",
       "file.read",
-      "file.patch"
+      "file.patch",
+      "git.diff",
+      "tests.run"
     ],
     escalationTriggers: [
       "Design-system mismatch",
@@ -3471,9 +3483,13 @@ var AGENT_CATALOG = {
     brainRole: "coder",
     purpose: "Implement backend behavior, contracts, and domain logic.",
     defaultTools: [
+      "file.list",
+      "file.search",
       "file.read",
       "file.patch",
-      "shell.exec"
+      "shell.exec",
+      "git.diff",
+      "tests.run"
     ],
     escalationTriggers: [
       "Schema drift",
@@ -3486,9 +3502,13 @@ var AGENT_CATALOG = {
     brainRole: "coder",
     purpose: "Own schema design, migrations, and persistence safety.",
     defaultTools: [
+      "file.list",
+      "file.search",
       "file.read",
       "file.patch",
-      "shell.exec"
+      "shell.exec",
+      "git.diff",
+      "tests.run"
     ],
     escalationTriggers: [
       "Data-destructive migration",
@@ -3501,9 +3521,13 @@ var AGENT_CATALOG = {
     brainRole: "coder",
     purpose: "Own local toolchain, packaging, CI, and environment plumbing.",
     defaultTools: [
+      "file.list",
+      "file.search",
       "file.read",
       "file.patch",
-      "shell.exec"
+      "shell.exec",
+      "git.diff",
+      "tests.run"
     ],
     escalationTriggers: [
       "Dependency installation",
@@ -3516,9 +3540,12 @@ var AGENT_CATALOG = {
     brainRole: "coder",
     purpose: "Run verification, interpret failures, and produce targeted repair loops.",
     defaultTools: [
+      "file.list",
+      "file.search",
       "file.read",
       "shell.exec",
-      "tests.run"
+      "tests.run",
+      "git.diff"
     ],
     escalationTriggers: [
       "Flaky verification",
@@ -3531,7 +3558,10 @@ var AGENT_CATALOG = {
     brainRole: "reviewer",
     purpose: "Inspect diffs for correctness, risk, and missing coverage before integration.",
     defaultTools: [
+      "file.list",
+      "file.search",
       "file.read",
+      "git.diff",
       "git.status",
       "tests.run"
     ],
@@ -3546,8 +3576,11 @@ var AGENT_CATALOG = {
     brainRole: "coder",
     purpose: "Combine accepted work, preserve repo consistency, and finalize the handoff state.",
     defaultTools: [
+      "file.list",
+      "file.search",
       "file.read",
       "file.patch",
+      "git.diff",
       "git.status",
       "tests.run"
     ],
@@ -3562,7 +3595,7 @@ function listAgentProfiles() {
   return Object.values(AGENT_CATALOG).sort((left, right) => left.role.localeCompare(right.role));
 }
 
-// ../agent-runtime/dist/orchestrator.js
+// ../agent-runtime/dist/autonomous.js
 var import_promises4 = require("node:fs/promises");
 var import_node_path4 = __toESM(require("node:path"), 1);
 
@@ -4044,8 +4077,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path6, errorMaps, issueData } = params;
-  const fullPath = [...path6, ...issueData.path || []];
+  const { data, path: path7, errorMaps, issueData } = params;
+  const fullPath = [...path7, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -4161,11 +4194,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path6, key) {
+  constructor(parent, value, path7, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path6;
+    this._path = path7;
     this._key = key;
   }
   get path() {
@@ -7837,6 +7870,8 @@ var SessionEventTypeSchema = external_exports.enum([
   "task-started",
   "task-completed",
   "task-blocked",
+  "task-handed-off",
+  "task-paused",
   "note"
 ]);
 var SessionEventSchema = external_exports.object({
@@ -8072,6 +8107,34 @@ function assignBrain(config, role, settings) {
     }
   });
 }
+function buildRetainedBrainSettings(current, providerId, model) {
+  return {
+    providerId,
+    ...model ? {
+      model
+    } : {},
+    ...typeof current.temperature === "number" ? {
+      temperature: current.temperature
+    } : {},
+    ...typeof current.maxTokens === "number" ? {
+      maxTokens: current.maxTokens
+    } : {},
+    ...current.promptPreamble ? {
+      promptPreamble: current.promptPreamble
+    } : {}
+  };
+}
+function assignProviderToAllBrains(config, providerId, model) {
+  return KimbhoConfigSchema.parse({
+    ...config,
+    brains: {
+      planner: buildRetainedBrainSettings(config.brains.planner, providerId, model),
+      coder: buildRetainedBrainSettings(config.brains.coder, providerId, model),
+      reviewer: buildRetainedBrainSettings(config.brains.reviewer, providerId, model),
+      fast: buildRetainedBrainSettings(config.brains.fast, providerId, model)
+    }
+  });
+}
 function resolveBrainSettings(config, role) {
   return config.brains[role];
 }
@@ -8136,1255 +8199,2137 @@ async function loadLatestSession(cwd = process.cwd()) {
   return loadSession(import_node_path2.default.join(sessionsDir, latest));
 }
 
-// ../tools/dist/types.js
-var ToolPermissionSchema = external_exports.enum([
-  "safe",
-  "approval-required",
-  "destructive"
-]);
-var ToolDescriptorSchema = external_exports.object({
-  id: external_exports.string().min(1),
-  description: external_exports.string().min(1),
-  permission: ToolPermissionSchema.default("safe"),
-  timeoutMs: external_exports.number().int().positive(),
-  retryable: external_exports.boolean().default(false),
-  producesArtifacts: external_exports.boolean().default(false),
-  allowedRoles: external_exports.array(AgentRoleSchema).default([])
-});
-
-// ../tools/dist/registry.js
-var BUILTIN_TOOLS = [
+// ../brains/dist/templates.js
+var BUILTIN_PROVIDER_TEMPLATES = [
   {
-    id: "file.read",
-    description: "Read a file from the workspace.",
-    permission: "safe",
-    timeoutMs: 5e3,
-    retryable: false,
-    producesArtifacts: false,
-    allowedRoles: [
-      "session-orchestrator",
-      "repo-analyst",
-      "planner",
-      "execution-manager",
-      "frontend-specialist",
-      "backend-specialist",
-      "database-specialist",
-      "infra-specialist",
-      "test-debugger",
-      "reviewer",
-      "integrator"
-    ]
+    id: "openai",
+    label: "OpenAI",
+    driver: "openai-responses",
+    defaultBaseUrl: "https://api.openai.com/v1",
+    defaultApiKeyEnv: "OPENAI_API_KEY",
+    defaultModel: "gpt-5",
+    notes: "Uses the OpenAI Responses API."
   },
   {
-    id: "file.patch",
-    description: "Apply a structured patch to workspace files.",
-    permission: "approval-required",
-    timeoutMs: 1e4,
-    retryable: true,
-    producesArtifacts: true,
-    allowedRoles: [
-      "frontend-specialist",
-      "backend-specialist",
-      "database-specialist",
-      "infra-specialist",
-      "test-debugger",
-      "integrator"
-    ]
+    id: "anthropic",
+    label: "Anthropic",
+    driver: "anthropic-messages",
+    defaultBaseUrl: "https://api.anthropic.com/v1/messages",
+    defaultApiKeyEnv: "ANTHROPIC_API_KEY",
+    notes: "Uses the Anthropic Messages API."
   },
   {
-    id: "shell.exec",
-    description: "Run a shell command inside the workspace.",
-    permission: "approval-required",
-    timeoutMs: 12e4,
-    retryable: true,
-    producesArtifacts: true,
-    allowedRoles: [
-      "repo-analyst",
-      "execution-manager",
-      "backend-specialist",
-      "infra-specialist",
-      "test-debugger",
-      "reviewer",
-      "integrator"
-    ]
+    id: "openrouter",
+    label: "OpenRouter",
+    driver: "openai-compatible",
+    defaultBaseUrl: "https://openrouter.ai/api/v1",
+    defaultApiKeyEnv: "OPENROUTER_API_KEY",
+    notes: "Routes through the OpenAI-compatible OpenRouter API."
   },
   {
-    id: "git.status",
-    description: "Inspect the current git working tree and diff state.",
-    permission: "safe",
-    timeoutMs: 1e4,
-    retryable: true,
-    producesArtifacts: false,
-    allowedRoles: [
-      "session-orchestrator",
-      "repo-analyst",
-      "execution-manager",
-      "reviewer",
-      "integrator"
-    ]
+    id: "ollama",
+    label: "Ollama",
+    driver: "ollama",
+    defaultBaseUrl: "http://localhost:11434",
+    defaultModel: "qwen2.5-coder:7b",
+    notes: "Runs against a local Ollama server."
   },
   {
-    id: "tests.run",
-    description: "Execute verification commands such as tests, linting, and builds.",
-    permission: "approval-required",
-    timeoutMs: 3e5,
-    retryable: true,
-    producesArtifacts: true,
-    allowedRoles: [
-      "execution-manager",
-      "test-debugger",
-      "reviewer",
-      "integrator"
-    ]
+    id: "lmstudio",
+    label: "LM Studio",
+    driver: "openai-compatible",
+    defaultBaseUrl: "http://localhost:1234/v1",
+    notes: "Works with LM Studio's local OpenAI-compatible server."
   }
 ];
-var ToolRegistry = class {
-  tools = /* @__PURE__ */ new Map();
-  constructor(seed = BUILTIN_TOOLS) {
-    for (const descriptor of seed) {
-      const normalized = ToolDescriptorSchema.parse(descriptor);
-      this.tools.set(normalized.id, normalized);
-    }
+function listProviderTemplates() {
+  return BUILTIN_PROVIDER_TEMPLATES.slice().sort((left, right) => left.id.localeCompare(right.id));
+}
+function findProviderTemplate(templateId) {
+  return BUILTIN_PROVIDER_TEMPLATES.find((template) => template.id === templateId);
+}
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function normalizeTemplateBaseUrl(templateId, baseUrl) {
+  if (!baseUrl) {
+    return void 0;
   }
-  list() {
-    return Array.from(this.tools.values()).sort((left, right) => left.id.localeCompare(right.id));
+  const normalized = trimTrailingSlash(baseUrl);
+  if (templateId !== "lmstudio") {
+    return normalized;
   }
-  get(id) {
-    return this.tools.get(id);
+  try {
+    const parsed = new URL(normalized);
+    if (!parsed.pathname || parsed.pathname === "/") {
+      parsed.pathname = "/v1";
+      return trimTrailingSlash(parsed.toString());
+    }
+  } catch {
+    return normalized;
   }
-  byRole(role) {
-    return this.list().filter((tool) => tool.allowedRoles.includes(role));
+  return normalized;
+}
+function buildProviderFromTemplate(templateId, options = {}) {
+  const template = findProviderTemplate(templateId);
+  if (!template) {
+    throw new Error(`Unknown provider template "${templateId}".`);
   }
-};
-function createDefaultToolRegistry() {
-  return new ToolRegistry(BUILTIN_TOOLS);
+  return ProviderDefinitionSchema.parse({
+    id: options.providerId ?? template.id,
+    label: options.label ?? template.label,
+    driver: template.driver,
+    ...normalizeTemplateBaseUrl(templateId, options.baseUrl) ?? template.defaultBaseUrl ? {
+      baseUrl: normalizeTemplateBaseUrl(templateId, options.baseUrl) ?? template.defaultBaseUrl
+    } : {},
+    ...options.apiKeyEnv ?? template.defaultApiKeyEnv ? {
+      apiKeyEnv: options.apiKeyEnv ?? template.defaultApiKeyEnv
+    } : {},
+    ...options.model ?? template.defaultModel ? {
+      defaultModel: options.model ?? template.defaultModel
+    } : {},
+    ...options.models && options.models.length > 0 ? {
+      models: options.models
+    } : {}
+  });
 }
 
-// ../tools/dist/runtime.js
+// ../brains/dist/registry.js
 var import_promises3 = require("node:fs/promises");
 var import_node_path3 = __toESM(require("node:path"), 1);
-var import_node_process = __toESM(require("node:process"), 1);
-var import_node_child_process = require("node:child_process");
-var import_node_os = require("node:os");
-var DEFAULT_CAPTURE_LIMIT = 16e3;
-function truncateOutput(value) {
-  if (!value) {
-    return value;
-  }
-  if (value.length <= DEFAULT_CAPTURE_LIMIT) {
-    return value;
+var import_node_url = require("node:url");
+function resolveApiKey(definition) {
+  if (!definition.apiKeyEnv) {
+    return null;
   }
-  const omitted = value.length - DEFAULT_CAPTURE_LIMIT;
-  return `${value.slice(0, DEFAULT_CAPTURE_LIMIT)}
-... [truncated ${omitted} chars]`;
+  return process.env[definition.apiKeyEnv] ?? null;
 }
-function resolveWorkspacePath(cwd, filePath) {
-  const resolved = import_node_path3.default.resolve(cwd, filePath);
-  const relative = import_node_path3.default.relative(cwd, resolved);
-  if (relative.startsWith("..") || import_node_path3.default.isAbsolute(relative)) {
-    throw new Error(`Path "${filePath}" escapes the workspace.`);
+function makeAbortSignal(timeoutMs) {
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(), timeoutMs).unref?.();
+  return controller.signal;
+}
+var GENERATION_TIMEOUT_MS = 12e4;
+async function requestJson(url, init, timeoutMs = 3e4) {
+  const response = await fetch(url, {
+    ...init,
+    signal: makeAbortSignal(timeoutMs)
+  });
+  if (!response.ok) {
+    throw new Error(`Request failed with ${response.status} ${response.statusText}`);
   }
-  return resolved;
+  return response.json();
 }
-async function runSpawn(command, args, cwd, timeoutMs) {
-  return new Promise((resolve, reject) => {
-    const child = (0, import_node_child_process.spawn)(command, args, {
-      cwd,
-      env: import_node_process.default.env,
-      stdio: [
-        "ignore",
-        "pipe",
-        "pipe"
-      ]
-    });
-    const stdout = [];
-    const stderr = [];
-    let settled = false;
-    let timedOut = false;
-    const timer = setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGTERM");
-      setTimeout(() => child.kill("SIGKILL"), 1e3).unref();
-    }, timeoutMs);
-    child.stdout.on("data", (chunk) => {
-      stdout.push(String(chunk));
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr.push(String(chunk));
-    });
-    child.on("error", (error) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      clearTimeout(timer);
-      reject(error);
-    });
-    child.on("close", (code) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      clearTimeout(timer);
-      resolve({
-        code,
-        stdout: stdout.join(""),
-        stderr: stderr.join(""),
-        timedOut
-      });
-    });
-  });
+function trimTrailingSlash2(value) {
+  return value.replace(/\/+$/, "");
 }
-async function runShellCommand(toolId, command, cwd, timeoutMs) {
-  const shell = import_node_process.default.env.SHELL ?? "/bin/sh";
-  const result = await runSpawn(shell, [
-    "-lc",
-    command
-  ], cwd, timeoutMs);
-  const success = !result.timedOut && result.code === 0;
-  const summary = result.timedOut ? `Command timed out after ${timeoutMs}ms.` : success ? `Command completed successfully.` : `Command exited with code ${result.code ?? "unknown"}.`;
-  return ToolResultSchema.parse({
-    toolId,
-    success,
-    summary,
-    stdout: truncateOutput(result.stdout),
-    stderr: truncateOutput(result.stderr)
-  });
+function joinUrl(baseUrl, suffix) {
+  const normalizedBase = trimTrailingSlash2(baseUrl);
+  const normalizedSuffix = suffix.startsWith("/") ? suffix : `/${suffix}`;
+  return `${normalizedBase}${normalizedSuffix}`;
 }
-async function executeFileRead(input, context) {
-  const rawPath = typeof input.path === "string" ? input.path : null;
-  if (!rawPath) {
-    throw new Error("file.read requires a string path.");
-  }
-  const targetPath = resolveWorkspacePath(context.cwd, rawPath);
-  const contents = await (0, import_promises3.readFile)(targetPath, "utf8");
-  return ToolResultSchema.parse({
-    toolId: "file.read",
-    success: true,
-    summary: `Read ${import_node_path3.default.relative(context.cwd, targetPath) || import_node_path3.default.basename(targetPath)}.`,
-    stdout: truncateOutput(contents),
-    artifacts: [
-      targetPath
-    ]
-  });
+function isOpenRouter(definition) {
+  return definition.baseUrl?.includes("openrouter.ai") ?? false;
 }
-async function executeShell(input, context, timeoutMs) {
-  const command = typeof input.command === "string" ? input.command : null;
-  if (!command) {
-    throw new Error("shell.exec requires a command string.");
+function buildProviderHeaders(definition, apiKey, includeJsonContentType = true) {
+  const headers = {
+    ...definition.headers
+  };
+  if (includeJsonContentType) {
+    headers["content-type"] = "application/json";
   }
-  return runShellCommand("shell.exec", command, context.cwd, timeoutMs);
+  if (apiKey) {
+    headers.authorization = `Bearer ${apiKey}`;
+  }
+  if (isOpenRouter(definition)) {
+    const siteUrl = process.env.OPENROUTER_SITE_URL;
+    const appName = process.env.OPENROUTER_APP_NAME ?? "Kimbho CLI";
+    if (siteUrl) {
+      headers["HTTP-Referer"] = siteUrl;
+    }
+    headers["X-Title"] = appName;
+  }
+  return headers;
 }
-async function executeGitStatus(_input, context, timeoutMs) {
-  return runShellCommand("git.status", "git status --short --branch", context.cwd, timeoutMs);
+function filterModels(models, input = {}) {
+  const normalized = input.search?.trim().toLowerCase();
+  const filtered = normalized ? models.filter((model) => [model.id, model.name].filter((value) => Boolean(value)).some((value) => value.toLowerCase().includes(normalized))) : models;
+  return typeof input.limit === "number" ? filtered.slice(0, input.limit) : filtered;
 }
-async function executeTests(input, context, timeoutMs) {
-  const command = typeof input.command === "string" && input.command.trim().length > 0 ? input.command : "npm test";
-  const result = await runShellCommand("tests.run", command, context.cwd, timeoutMs);
-  return ToolResultSchema.parse({
-    ...result,
-    summary: result.success ? `Verification command passed: ${command}` : `Verification command failed: ${command}`
+function mapOpenAIStyleModels(providerId, payload, input) {
+  const response = payload;
+  const data = Array.isArray(response.data) ? response.data : [];
+  const models = data.flatMap((item) => {
+    if (typeof item !== "object" || item === null) {
+      return [];
+    }
+    const record = item;
+    const pricing = typeof record.pricing === "object" && record.pricing !== null ? record.pricing : null;
+    const architecture = typeof record.architecture === "object" && record.architecture !== null ? record.architecture : null;
+    return [
+      ProviderModelSchema.parse({
+        id: String(record.id ?? ""),
+        ...typeof record.name === "string" ? {
+          name: record.name
+        } : {},
+        ...typeof record.description === "string" ? {
+          description: record.description
+        } : {},
+        ...typeof record.context_length === "number" ? {
+          contextLength: record.context_length
+        } : {},
+        ...pricing && typeof pricing.prompt === "string" ? {
+          promptPrice: pricing.prompt
+        } : {},
+        ...pricing && typeof pricing.completion === "string" ? {
+          completionPrice: pricing.completion
+        } : {},
+        ...architecture && typeof architecture.modality === "string" ? {
+          modality: architecture.modality
+        } : {},
+        providerId
+      })
+    ];
   });
+  return filterModels(models, input);
 }
-async function executeFilePatch(input, context, timeoutMs) {
-  const patch = typeof input.patch === "string" ? input.patch : null;
-  if (!patch) {
-    throw new Error("file.patch requires a unified diff in the patch field.");
+function mapAnthropicModels(providerId, payload, input) {
+  const response = payload;
+  const data = Array.isArray(response.data) ? response.data : [];
+  const models = data.flatMap((item) => {
+    if (typeof item !== "object" || item === null) {
+      return [];
+    }
+    const record = item;
+    return [
+      ProviderModelSchema.parse({
+        id: String(record.id ?? ""),
+        ...typeof record.display_name === "string" ? {
+          name: record.display_name
+        } : {},
+        providerId
+      })
+    ];
+  });
+  return filterModels(models, input);
+}
+function mapOllamaModels(providerId, payload, input) {
+  const response = payload;
+  const data = Array.isArray(response.models) ? response.models : [];
+  const models = data.flatMap((item) => {
+    if (typeof item !== "object" || item === null) {
+      return [];
+    }
+    const record = item;
+    const details = typeof record.details === "object" && record.details !== null ? record.details : null;
+    const id = typeof record.model === "string" ? record.model : typeof record.name === "string" ? record.name : "";
+    return [
+      ProviderModelSchema.parse({
+        id,
+        ...typeof record.name === "string" ? {
+          name: record.name
+        } : {},
+        ...details && typeof details.family === "string" ? {
+          modality: details.family
+        } : {},
+        ...details && typeof details.parameter_size === "string" ? {
+          description: details.parameter_size
+        } : {},
+        providerId
+      })
+    ];
+  });
+  return filterModels(models, input);
+}
+function toChatMessages(input) {
+  const messages = [];
+  if (input.systemPrompt) {
+    messages.push({
+      role: "system",
+      content: input.systemPrompt
+    });
   }
-  const tempDir = await (0, import_promises3.mkdtemp)(import_node_path3.default.join((0, import_node_os.tmpdir)(), "kimbho-patch-"));
-  const patchPath = import_node_path3.default.join(tempDir, "change.patch");
-  try {
-    await (0, import_promises3.writeFile)(patchPath, patch, "utf8");
-    const result = await runSpawn("git", [
-      "apply",
-      "--recount",
-      "--whitespace=nowarn",
-      patchPath
-    ], context.cwd, timeoutMs);
-    const success = !result.timedOut && result.code === 0;
-    return ToolResultSchema.parse({
-      toolId: "file.patch",
-      success,
-      summary: success ? "Patch applied successfully." : result.timedOut ? `Patch timed out after ${timeoutMs}ms.` : `Patch failed with code ${result.code ?? "unknown"}.`,
-      stdout: truncateOutput(result.stdout),
-      stderr: truncateOutput(result.stderr),
-      artifacts: []
+  if (input.messages && input.messages.length > 0) {
+    messages.push(...input.messages);
+  } else if (input.userPrompt) {
+    messages.push({
+      role: "user",
+      content: input.userPrompt
     });
-  } finally {
-    await (0, import_promises3.rm)(tempDir, { recursive: true, force: true });
   }
+  return messages;
 }
-var ToolRuntime = class {
-  registry;
-  executors;
-  constructor(registry = createDefaultToolRegistry()) {
-    this.registry = registry;
-    this.executors = /* @__PURE__ */ new Map([
-      [
-        "file.read",
-        (input, context) => executeFileRead(input, context)
-      ],
-      [
-        "file.patch",
-        executeFilePatch
-      ],
-      [
-        "shell.exec",
-        executeShell
-      ],
-      [
-        "git.status",
-        executeGitStatus
-      ],
-      [
-        "tests.run",
-        executeTests
-      ]
-    ]);
+function toPromptText(input) {
+  const messages = toChatMessages(input);
+  return messages.map((message) => `${message.role.toUpperCase()}: ${message.content}`).join("\n\n");
+}
+function requireModel(definition, input) {
+  const model = input.model ?? definition.defaultModel;
+  if (!model) {
+    throw new Error(`Provider "${definition.id}" does not have a resolved model.`);
   }
-  async run(toolId, input, context) {
-    const descriptor = this.registry.get(toolId);
-    if (!descriptor) {
-      throw new Error(`Unknown tool "${toolId}".`);
-    }
-    const executor = this.executors.get(toolId);
-    if (!executor) {
-      throw new Error(`No executor registered for "${toolId}".`);
-    }
-    return executor(input, context, descriptor.timeoutMs);
-  }
-};
-
-// ../agent-runtime/dist/orchestrator.js
-function createSessionId() {
-  return `session-${Date.now()}`;
-}
-function createEventId(type, taskId) {
-  return `${type}-${taskId ?? "session"}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-}
-function isTaskReady(task, completedTaskIds) {
-  return task.status === "pending" && task.dependsOn.every((taskId) => completedTaskIds.has(taskId));
-}
-function completedTaskIdsFromPlan(plan) {
-  return new Set(flattenPlanTasks(plan).filter((task) => task.status === "completed").map((task) => task.id));
+  return model;
 }
-function deriveStatus(plan, readyTasks, blockedTasks) {
-  const tasks = flattenPlanTasks(plan);
-  const completed = tasks.filter((task) => task.status === "completed").length;
-  if (completed === tasks.length && tasks.length > 0) {
-    return "completed";
-  }
-  if (readyTasks.length > 0) {
-    return completed > 0 ? "running" : "ready";
-  }
-  if (blockedTasks.length > 0) {
-    return "blocked";
+var OpenAIResponsesProvider = class {
+  definition;
+  constructor(definition) {
+    this.definition = ProviderDefinitionSchema.parse(definition);
   }
-  return "planned";
-}
-function updateTaskStatus(plan, taskId, status) {
-  const milestones = plan.milestones.map((milestone) => ({
-    ...milestone,
-    tasks: milestone.tasks.map((task) => task.id === taskId ? {
-      ...task,
-      status
-    } : task)
-  }));
-  return {
-    ...plan,
-    milestones
-  };
-}
-function maybeAppendNote(notes, note) {
-  return notes.at(-1) === note ? notes : [
-    ...notes,
-    note
-  ];
-}
-function renderToolResultSection(results) {
-  return results.map((result) => {
-    const lines = [
-      `## ${result.toolId}`,
-      `- success: ${result.success ? "yes" : "no"}`,
-      `- summary: ${result.summary}`
-    ];
-    if (result.stdout) {
-      lines.push("");
-      lines.push("```text");
-      lines.push(result.stdout);
-      lines.push("```");
+  async healthCheck() {
+    const apiKey = resolveApiKey(this.definition);
+    if (!apiKey) {
+      return {
+        ok: false,
+        message: `Missing ${this.definition.apiKeyEnv ?? "API key env var"}`
+      };
     }
-    if (result.stderr) {
-      lines.push("");
-      lines.push("```text");
-      lines.push(result.stderr);
-      lines.push("```");
+    return {
+      ok: true,
+      message: `${this.definition.baseUrl ?? "https://api.openai.com/v1"} (${this.definition.defaultModel ?? "model not set"})`
+    };
+  }
+  async listModels(input) {
+    const apiKey = resolveApiKey(this.definition);
+    if (!apiKey) {
+      throw new Error(`Missing ${this.definition.apiKeyEnv ?? "API key env var"} for provider "${this.definition.id}".`);
     }
-    return lines.join("\n");
-  }).join("\n\n");
-}
-function extractPackageScripts(toolResults) {
-  const packageResult = toolResults.find((result) => result.artifacts.some((artifact) => artifact.endsWith("package.json")) && result.stdout);
-  if (!packageResult?.stdout) {
-    return [];
+    const baseUrl = this.definition.baseUrl ?? "https://api.openai.com/v1";
+    const payload = await requestJson(joinUrl(baseUrl, "/models"), {
+      method: "GET",
+      headers: buildProviderHeaders(this.definition, apiKey, false)
+    });
+    return mapOpenAIStyleModels(this.definition.id, payload, input);
   }
-  try {
-    const parsed = JSON.parse(packageResult.stdout);
-    return Object.keys(parsed.scripts ?? {}).sort();
-  } catch {
-    return [];
+  async generateText(input) {
+    const apiKey = resolveApiKey(this.definition);
+    if (!apiKey) {
+      throw new Error(`Missing ${this.definition.apiKeyEnv ?? "API key env var"} for provider "${this.definition.id}".`);
+    }
+    const baseUrl = this.definition.baseUrl ?? "https://api.openai.com/v1";
+    const model = requireModel(this.definition, input);
+    const messages = toChatMessages(input).map((message) => ({
+      role: message.role,
+      content: [
+        {
+          type: "input_text",
+          text: message.content
+        }
+      ]
+    }));
+    const response = await requestJson(`${baseUrl}/responses`, {
+      method: "POST",
+      headers: {
+        ...buildProviderHeaders(this.definition, apiKey)
+      },
+      body: JSON.stringify({
+        model,
+        input: messages,
+        ...typeof input.temperature === "number" ? {
+          temperature: input.temperature
+        } : {},
+        ...typeof input.maxTokens === "number" ? {
+          max_output_tokens: input.maxTokens
+        } : {}
+      })
+    }, GENERATION_TIMEOUT_MS);
+    const text = typeof response.output_text === "string" ? response.output_text : Array.isArray(response.output) ? response.output.flatMap((item) => typeof item === "object" && item !== null && "content" in item && Array.isArray(item.content) ? item.content : []).flatMap((item) => typeof item === "object" && item !== null && "text" in item ? [
+      String(item.text)
+    ] : []).join("\n") : "";
+    return {
+      text,
+      model
+    };
   }
-}
-var ExecutionOrchestrator = class {
-  toolRegistry;
-  toolRuntime;
-  constructor(toolRegistry = createDefaultToolRegistry(), toolRuntime = new ToolRuntime(toolRegistry)) {
-    this.toolRegistry = toolRegistry;
-    this.toolRuntime = toolRuntime;
+};
+var AnthropicMessagesProvider = class {
+  definition;
+  constructor(definition) {
+    this.definition = ProviderDefinitionSchema.parse(definition);
   }
-  buildEnvelope(request, plan, sessionId = createSessionId()) {
-    const tasks = flattenPlanTasks(plan);
-    const completedTaskIds = completedTaskIdsFromPlan(plan);
-    const readyTasks = tasks.filter((task) => isTaskReady(task, completedTaskIds));
-    const blockedTasks = tasks.filter((task) => task.status !== "completed" && !isTaskReady(task, completedTaskIds));
-    const assignedAgents = this.selectAgentsForTasks(readyTasks);
+  async healthCheck() {
+    const apiKey = resolveApiKey(this.definition);
+    if (!apiKey) {
+      return {
+        ok: false,
+        message: `Missing ${this.definition.apiKeyEnv ?? "ANTHROPIC_API_KEY"}`
+      };
+    }
     return {
-      sessionId,
-      request,
-      plan,
-      readyTasks,
-      blockedTasks,
-      assignedAgents
+      ok: true,
+      message: `${this.definition.baseUrl ?? "https://api.anthropic.com/v1/messages"} (${this.definition.defaultModel ?? "model not set"})`
     };
   }
-  createSessionSnapshot(envelope, overrides = {}) {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const status = deriveStatus(envelope.plan, envelope.readyTasks, envelope.blockedTasks);
-    return SessionSnapshotSchema.parse({
-      id: envelope.sessionId,
-      goal: envelope.request.goal,
-      cwd: envelope.request.cwd,
-      startedAt: timestamp,
-      updatedAt: timestamp,
-      status,
-      request: envelope.request,
-      plan: envelope.plan,
-      readyTaskIds: envelope.readyTasks.map((task) => task.id),
-      blockedTaskIds: envelope.blockedTasks.map((task) => task.id),
-      completedTaskIds: Array.from(completedTaskIdsFromPlan(envelope.plan)),
-      assignedAgents: envelope.assignedAgents.map((agent) => agent.role),
-      notes: [
-        "Initial session snapshot created from the current plan."
-      ],
-      events: [],
-      ...overrides
+  async listModels(input) {
+    const apiKey = resolveApiKey(this.definition);
+    if (!apiKey) {
+      throw new Error(`Missing ${this.definition.apiKeyEnv ?? "ANTHROPIC_API_KEY"} for provider "${this.definition.id}".`);
+    }
+    const endpoint = this.definition.baseUrl ?? "https://api.anthropic.com/v1/messages";
+    const modelsEndpoint = endpoint.endsWith("/messages") ? `${endpoint.slice(0, -"/messages".length)}/models` : joinUrl(endpoint, "/models");
+    const payload = await requestJson(modelsEndpoint, {
+      method: "GET",
+      headers: {
+        "anthropic-version": "2023-06-01",
+        "x-api-key": apiKey,
+        ...this.definition.headers
+      }
     });
+    return mapAnthropicModels(this.definition.id, payload, input);
   }
-  async continueSession(session, options = {}) {
-    let workingPlan = session.plan;
-    let notes = [
-      ...session.notes
-    ];
-    let events = [
-      ...session.events
-    ];
-    const maxAutoTasks = options.maxAutoTasks ?? 2;
-    let executedTasks = 0;
-    while (executedTasks < maxAutoTasks) {
-      const envelope = this.buildEnvelope(session.request, workingPlan, session.id);
-      const autoTask = envelope.readyTasks.find((task) => this.canAutoExecuteTask(task));
-      if (!autoTask) {
-        const nextTask = envelope.readyTasks[0];
-        if (nextTask) {
-          const note = `Execution paused at ${nextTask.id} (${nextTask.title}): no built-in executor is wired for ${nextTask.agentRole} yet.`;
-          notes = maybeAppendNote(notes, note);
-        }
-        return this.createSessionSnapshot(this.buildEnvelope(session.request, workingPlan, session.id), {
-          startedAt: session.startedAt,
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          notes,
-          events
-        });
-      }
-      events.push({
-        id: createEventId("task-started", autoTask.id),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        type: "task-started",
-        taskId: autoTask.id,
-        agentRole: autoTask.agentRole,
-        message: `Started ${autoTask.id}: ${autoTask.title}`,
-        toolResults: [],
-        artifacts: []
-      });
-      const outcome = await this.executeTask(session.id, autoTask, session.request, workingPlan);
-      workingPlan = updateTaskStatus(workingPlan, autoTask.id, outcome.status === "completed" ? "completed" : "blocked");
-      notes = maybeAppendNote(notes, outcome.summary);
-      events.push({
-        id: createEventId(outcome.status === "completed" ? "task-completed" : "task-blocked", autoTask.id),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        type: outcome.status === "completed" ? "task-completed" : "task-blocked",
-        taskId: autoTask.id,
-        agentRole: autoTask.agentRole,
-        message: outcome.summary,
-        toolResults: outcome.toolResults,
-        artifacts: outcome.artifacts
+  async generateText(input) {
+    const apiKey = resolveApiKey(this.definition);
+    if (!apiKey) {
+      throw new Error(`Missing ${this.definition.apiKeyEnv ?? "ANTHROPIC_API_KEY"} for provider "${this.definition.id}".`);
+    }
+    const endpoint = this.definition.baseUrl ?? "https://api.anthropic.com/v1/messages";
+    const model = requireModel(this.definition, input);
+    const messages = toChatMessages(input);
+    const systemMessage = messages.find((message) => message.role === "system")?.content;
+    const conversation = messages.filter((message) => message.role !== "system").map((message) => ({
+      role: message.role === "assistant" ? "assistant" : "user",
+      content: message.content
+    }));
+    const response = await requestJson(endpoint, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        ...this.definition.headers
+      },
+      body: JSON.stringify({
+        model,
+        messages: conversation,
+        ...systemMessage ? {
+          system: systemMessage
+        } : {},
+        max_tokens: input.maxTokens ?? 2048,
+        ...typeof input.temperature === "number" ? {
+          temperature: input.temperature
+        } : {}
+      })
+    }, GENERATION_TIMEOUT_MS);
+    const content = Array.isArray(response.content) ? response.content : [];
+    const text = content.flatMap((item) => typeof item === "object" && item !== null && "text" in item ? [
+      String(item.text)
+    ] : []).join("\n");
+    return {
+      text,
+      model
+    };
+  }
+};
+var OpenAICompatibleProvider = class {
+  definition;
+  constructor(definition) {
+    this.definition = ProviderDefinitionSchema.parse(definition);
+  }
+  async healthCheck() {
+    if (!this.definition.baseUrl) {
+      return {
+        ok: false,
+        message: "Missing baseUrl"
+      };
+    }
+    const apiKey = resolveApiKey(this.definition);
+    if (this.definition.apiKeyEnv && !apiKey) {
+      return {
+        ok: false,
+        message: `${this.definition.baseUrl} (${this.definition.defaultModel ?? "model not set"}), missing ${this.definition.apiKeyEnv}`
+      };
+    }
+    try {
+      await requestJson(joinUrl(this.definition.baseUrl, "/models"), {
+        method: "GET",
+        headers: buildProviderHeaders(this.definition, apiKey, false)
+      }, 2e3);
+    } catch (error) {
+      return {
+        ok: false,
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+    return {
+      ok: true,
+      message: `${this.definition.baseUrl} (${this.definition.defaultModel ?? "model not set"})`
+    };
+  }
+  async listModels(input) {
+    if (!this.definition.baseUrl) {
+      throw new Error(`Provider "${this.definition.id}" requires baseUrl.`);
+    }
+    const apiKey = resolveApiKey(this.definition);
+    const payload = await requestJson(joinUrl(this.definition.baseUrl, "/models"), {
+      method: "GET",
+      headers: buildProviderHeaders(this.definition, apiKey, false)
+    });
+    return mapOpenAIStyleModels(this.definition.id, payload, input);
+  }
+  async generateText(input) {
+    if (!this.definition.baseUrl) {
+      throw new Error(`Provider "${this.definition.id}" requires baseUrl.`);
+    }
+    const apiKey = resolveApiKey(this.definition);
+    const model = requireModel(this.definition, input);
+    const response = await requestJson(`${this.definition.baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: buildProviderHeaders(this.definition, apiKey),
+      body: JSON.stringify({
+        model,
+        messages: toChatMessages(input),
+        ...typeof input.temperature === "number" ? {
+          temperature: input.temperature
+        } : {},
+        ...typeof input.maxTokens === "number" ? {
+          max_tokens: input.maxTokens
+        } : {}
+      })
+    }, GENERATION_TIMEOUT_MS);
+    const choices = Array.isArray(response.choices) ? response.choices : [];
+    const firstChoice = choices.length > 0 && typeof choices[0] === "object" && choices[0] !== null ? choices[0] : null;
+    const message = firstChoice && typeof firstChoice.message === "object" && firstChoice.message !== null ? firstChoice.message : null;
+    return {
+      text: typeof message?.content === "string" ? message.content : "",
+      model
+    };
+  }
+};
+var OllamaProvider = class {
+  definition;
+  constructor(definition) {
+    this.definition = ProviderDefinitionSchema.parse(definition);
+  }
+  async healthCheck() {
+    const baseUrl = this.definition.baseUrl ?? "http://localhost:11434";
+    try {
+      await requestJson(`${baseUrl}/api/tags`, { method: "GET" }, 2e3);
+      return {
+        ok: true,
+        message: `${baseUrl} (${this.definition.defaultModel ?? "model not set"})`
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        message: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  async listModels(input) {
+    const baseUrl = this.definition.baseUrl ?? "http://localhost:11434";
+    const payload = await requestJson(`${baseUrl}/api/tags`, { method: "GET" }, 2e3);
+    return mapOllamaModels(this.definition.id, payload, input);
+  }
+  async generateText(input) {
+    const baseUrl = this.definition.baseUrl ?? "http://localhost:11434";
+    const model = requireModel(this.definition, input);
+    const response = await requestJson(`${baseUrl}/api/generate`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...this.definition.headers
+      },
+      body: JSON.stringify({
+        model,
+        prompt: input.userPrompt ?? toPromptText(input),
+        ...input.systemPrompt ? {
+          system: input.systemPrompt
+        } : {},
+        stream: false,
+        ...typeof input.temperature === "number" ? {
+          options: {
+            temperature: input.temperature
+          }
+        } : {}
+      })
+    }, GENERATION_TIMEOUT_MS);
+    return {
+      text: typeof response.response === "string" ? response.response : "",
+      model
+    };
+  }
+};
+async function createCustomModuleProvider(definition, cwd) {
+  if (!definition.modulePath) {
+    throw new Error(`Provider "${definition.id}" requires modulePath.`);
+  }
+  const modulePath = import_node_path3.default.isAbsolute(definition.modulePath) ? definition.modulePath : import_node_path3.default.join(cwd, definition.modulePath);
+  await (0, import_promises3.access)(modulePath);
+  const module2 = await import((0, import_node_url.pathToFileURL)(modulePath).href);
+  const createProvider = typeof module2.createProvider === "function" ? module2.createProvider : typeof module2.default === "function" ? module2.default : null;
+  if (!createProvider) {
+    throw new Error(`Custom provider module "${modulePath}" must export createProvider(definition).`);
+  }
+  return createProvider(definition);
+}
+var BUILTIN_FACTORIES = {
+  "openai-responses": {
+    driver: "openai-responses",
+    create: async (definition) => new OpenAIResponsesProvider(definition)
+  },
+  "anthropic-messages": {
+    driver: "anthropic-messages",
+    create: async (definition) => new AnthropicMessagesProvider(definition)
+  },
+  "openai-compatible": {
+    driver: "openai-compatible",
+    create: async (definition) => new OpenAICompatibleProvider(definition)
+  },
+  ollama: {
+    driver: "ollama",
+    create: async (definition) => new OllamaProvider(definition)
+  },
+  "custom-module": {
+    driver: "custom-module",
+    create: (definition, cwd) => createCustomModuleProvider(definition, cwd)
+  }
+};
+var BrainProviderRegistry = class {
+  cwd;
+  factories;
+  constructor(cwd = process.cwd(), factories = Object.values(BUILTIN_FACTORIES)) {
+    this.cwd = cwd;
+    this.factories = new Map(factories.map((factory) => [factory.driver, factory]));
+  }
+  listDrivers() {
+    return Array.from(this.factories.keys()).sort();
+  }
+  async createProvider(definition) {
+    const normalized = ProviderDefinitionSchema.parse(definition);
+    const factory = this.factories.get(normalized.driver);
+    if (!factory) {
+      throw new Error(`No provider factory registered for driver "${normalized.driver}".`);
+    }
+    return factory.create(normalized, this.cwd);
+  }
+  async healthCheck(definition) {
+    const provider = await this.createProvider(definition);
+    return provider.healthCheck();
+  }
+  async listModels(definition, input) {
+    const provider = await this.createProvider(definition);
+    if (provider.listModels) {
+      return provider.listModels(input);
+    }
+    return filterModels(definition.models.map((modelId) => ProviderModelSchema.parse({
+      id: modelId,
+      providerId: definition.id
+    })), input);
+  }
+};
+function createDefaultBrainProviderRegistry(cwd = process.cwd()) {
+  return new BrainProviderRegistry(cwd);
+}
+
+// ../brains/dist/resolver.js
+var BrainResolver = class {
+  config;
+  registry;
+  constructor(config, registry = createDefaultBrainProviderRegistry()) {
+    this.config = config;
+    this.registry = registry;
+  }
+  async resolve(role) {
+    const settings = resolveBrainSettings(this.config, role);
+    const provider = findProviderById(this.config, settings.providerId);
+    if (!provider) {
+      throw new Error(`Brain role "${role}" points to unknown provider "${settings.providerId}".`);
+    }
+    const model = resolveBrainModel(this.config, role);
+    if (!model) {
+      throw new Error(`Brain role "${role}" does not resolve to a model.`);
+    }
+    return {
+      role,
+      settings,
+      provider,
+      model,
+      client: await this.registry.createProvider(provider)
+    };
+  }
+};
+
+// ../agent-runtime/dist/autonomous.js
+var MAX_TOOL_OUTPUT_CHARS = 4e3;
+var MAX_PARSE_RETRIES = 2;
+var DEFAULT_MAX_REPAIR_ATTEMPTS = 2;
+var MODEL_ACTION_TOOLS = [
+  "file.list",
+  "file.search",
+  "file.read",
+  "file.write",
+  "file.patch",
+  "shell.exec",
+  "tests.run",
+  "git.status",
+  "git.diff"
+];
+function createAgentActionSchema(allowedTools) {
+  return external_exports.discriminatedUnion("type", [
+    external_exports.object({
+      type: external_exports.literal("tool"),
+      tool: external_exports.enum(MODEL_ACTION_TOOLS).refine((tool) => allowedTools.includes(tool), {
+        message: `Tool must be one of: ${allowedTools.join(", ")}`
+      }),
+      input: external_exports.record(external_exports.union([
+        external_exports.string(),
+        external_exports.number(),
+        external_exports.boolean(),
+        external_exports.null()
+      ])).default({}),
+      reason: external_exports.string().min(1).optional()
+    }),
+    external_exports.object({
+      type: external_exports.literal("finish"),
+      summary: external_exports.string().min(1)
+    }),
+    external_exports.object({
+      type: external_exports.literal("block"),
+      reason: external_exports.string().min(1)
+    })
+  ]);
+}
+function truncateForModel(value) {
+  if (!value) {
+    return value;
+  }
+  if (value.length <= MAX_TOOL_OUTPUT_CHARS) {
+    return value;
+  }
+  return `${value.slice(0, MAX_TOOL_OUTPUT_CHARS)}
+... [truncated]`;
+}
+function extractJsonObject(raw) {
+  const fenced = raw.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const candidate = (fenced?.[1] ?? raw).trim();
+  const firstBrace = candidate.indexOf("{");
+  const lastBrace = candidate.lastIndexOf("}");
+  if (firstBrace === -1 || lastBrace === -1 || lastBrace <= firstBrace) {
+    throw new Error("Expected a JSON object in the model response.");
+  }
+  return JSON.parse(candidate.slice(firstBrace, lastBrace + 1));
+}
+function renderToolResultForModel(result) {
+  const sections = [
+    `tool: ${result.toolId}`,
+    `success: ${result.success ? "true" : "false"}`,
+    `summary: ${result.summary}`
+  ];
+  if (result.stdout) {
+    sections.push(`stdout:
+${truncateForModel(result.stdout)}`);
+  }
+  if (result.stderr) {
+    sections.push(`stderr:
+${truncateForModel(result.stderr)}`);
+  }
+  if (result.artifacts.length > 0) {
+    sections.push(`artifacts: ${result.artifacts.join(", ")}`);
+  }
+  return sections.join("\n");
+}
+function isReadOnlyShellCommand(command) {
+  const normalized = command.trim().toLowerCase();
+  return [
+    "pwd",
+    "ls",
+    "find ",
+    "rg ",
+    "grep ",
+    "cat ",
+    "sed ",
+    "head ",
+    "tail ",
+    "git status",
+    "git diff"
+  ].some((prefix) => normalized === prefix || normalized.startsWith(prefix));
+}
+function isVerificationCommand(command) {
+  const normalized = command.trim().toLowerCase();
+  return [
+    "npm test",
+    "npm run test",
+    "npm run build",
+    "npm run lint",
+    "pnpm test",
+    "pnpm build",
+    "pnpm lint",
+    "yarn test",
+    "yarn build",
+    "yarn lint",
+    "tsc",
+    "vitest",
+    "jest"
+  ].some((prefix) => normalized === prefix || normalized.startsWith(prefix));
+}
+function isMutatingAction(action) {
+  if (action.type !== "tool") {
+    return false;
+  }
+  if (action.tool === "file.write" || action.tool === "file.patch") {
+    return true;
+  }
+  if (action.tool !== "shell.exec") {
+    return false;
+  }
+  const command = typeof action.input.command === "string" ? action.input.command : "";
+  return command.length > 0 && !isReadOnlyShellCommand(command);
+}
+function isVerificationAction(action) {
+  if (action.type !== "tool") {
+    return false;
+  }
+  if (action.tool === "tests.run") {
+    return true;
+  }
+  if (action.tool !== "shell.exec") {
+    return false;
+  }
+  const command = typeof action.input.command === "string" ? action.input.command : "";
+  return command.length > 0 && isVerificationCommand(command);
+}
+function buildSystemPrompt(agent, task, request, allowedTools) {
+  const toolShape = allowedTools.join("|");
+  return [
+    `You are Kimbho's ${agent.role}.`,
+    `Purpose: ${agent.purpose}`,
+    `Goal: ${request.goal}`,
+    `Current task: ${task.id} - ${task.title}`,
+    `Task description: ${task.description}`,
+    `Acceptance criteria:`,
+    ...task.acceptanceCriteria.map((item) => `- ${item}`),
+    `Likely files: ${task.filesLikelyTouched.join(", ") || "(not specified)"}`,
+    `Workspace state: ${request.workspaceState}`,
+    `Allowed tools: ${allowedTools.join(", ")}`,
+    `Respond with exactly one JSON object and no markdown.`,
+    `Tool action shape: {"type":"tool","tool":"${toolShape}","input":{...},"reason":"why this step matters"}`,
+    `Finish shape: {"type":"finish","summary":"what was completed and verified"}`,
+    `Block shape: {"type":"block","reason":"why you cannot proceed safely"}`,
+    `Rules:`,
+    `- Use one action per response.`,
+    `- Use file.list and file.search to explore the workspace before editing.`,
+    `- Prefer file.read before editing existing files.`,
+    `- Use file.patch for existing files when possible; use file.write for new files or full replacements.`,
+    `- Use git.diff to inspect the current patch after changes when helpful.`,
+    `- Use shell.exec for non-interactive commands only.`,
+    `- Keep paths relative to the workspace.`,
+    `- After changing code, run verification with tests.run or shell.exec when appropriate.`,
+    `- Do not claim success unless the task acceptance criteria are satisfied.`,
+    `- If the task is underspecified, make a pragmatic implementation choice and continue.`
+  ].join("\n");
+}
+function buildInitialUserPrompt(task, request) {
+  return [
+    `Complete this task in the workspace.`,
+    `Task type: ${task.type}`,
+    `Risk level: ${task.riskLevel}`,
+    `Outputs expected: ${task.outputs.join(", ") || "(not specified)"}`,
+    `Constraints: ${request.constraints.join(", ") || "(none)"}`,
+    `Choose the next single action now.`
+  ].join("\n");
+}
+function buildToolResultUserMessage(step, result) {
+  return [
+    `Step ${step} tool result:`,
+    renderToolResultForModel(result),
+    `Choose the next single action now.`
+  ].join("\n\n");
+}
+function createToolFailureResult(toolId, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    toolId,
+    success: false,
+    summary: `${toolId} failed: ${message}`,
+    stderr: message,
+    artifacts: []
+  };
+}
+async function writeTranscriptArtifact(cwd, sessionId, taskId, entries) {
+  await ensureKimbhoDir(cwd);
+  const outputPath = import_node_path4.default.join(resolveKimbhoDir(cwd), "logs", `${sessionId}-${taskId}-autonomous.md`);
+  const content = [
+    `# Autonomous Task Transcript`,
+    ``,
+    `- session: ${sessionId}`,
+    `- task: ${taskId}`,
+    ``,
+    ...entries.flatMap((entry) => {
+      const lines = [
+        `## Step ${entry.step}`,
+        ``,
+        `### Model Response`,
+        `\`\`\`json`,
+        entry.response.trim(),
+        `\`\`\``
+      ];
+      if (entry.toolResult) {
+        lines.push("");
+        lines.push(`### Tool Result`);
+        lines.push(`- tool: ${entry.toolResult.toolId}`);
+        lines.push(`- success: ${entry.toolResult.success ? "true" : "false"}`);
+        lines.push(`- summary: ${entry.toolResult.summary}`);
+        if (entry.toolResult.stdout) {
+          lines.push("");
+          lines.push("```text");
+          lines.push(truncateForModel(entry.toolResult.stdout) ?? "");
+          lines.push("```");
+        }
+        if (entry.toolResult.stderr) {
+          lines.push("");
+          lines.push("```text");
+          lines.push(truncateForModel(entry.toolResult.stderr) ?? "");
+          lines.push("```");
+        }
+      }
+      if (entry.runtimeNote) {
+        lines.push("");
+        lines.push(`### Runtime Note`);
+        lines.push(entry.runtimeNote);
+      }
+      lines.push("");
+      return lines;
+    })
+  ].join("\n");
+  await (0, import_promises4.writeFile)(outputPath, `${content}
+`, "utf8");
+  return outputPath;
+}
+var AutonomousTaskExecutor = class {
+  config;
+  resolver;
+  toolRegistry;
+  toolRuntime;
+  constructor(config, toolRegistry, toolRuntime) {
+    this.config = config;
+    this.resolver = new BrainResolver(config);
+    this.toolRegistry = toolRegistry;
+    this.toolRuntime = toolRuntime;
+  }
+  async execute(sessionId, task, request, options = {}) {
+    const agent = AGENT_CATALOG[task.agentRole];
+    const brain = await this.resolver.resolve(agent.brainRole);
+    const allowedTools = this.toolRegistry.byRole(agent.role).map((tool) => tool.id);
+    const actionSchema = createAgentActionSchema(allowedTools);
+    const messages = [
+      {
+        role: "user",
+        content: buildInitialUserPrompt(task, request)
+      }
+    ];
+    const toolResults = [];
+    const artifacts = /* @__PURE__ */ new Set();
+    const transcript = [];
+    const maxSteps = options.maxSteps ?? 10;
+    const maxRepairAttempts = options.maxRepairAttempts ?? DEFAULT_MAX_REPAIR_ATTEMPTS;
+    let changedWorkspace = false;
+    let verifiedAfterLatestChange = false;
+    let repairRequiredBeforeVerification = false;
+    let repairAppliedSinceFailure = false;
+    let verificationFailures = 0;
+    let lastVerificationFailure = null;
+    for (let step = 1; step <= maxSteps; step += 1) {
+      let responseText = "";
+      let parsedAction = null;
+      for (let attempt = 0; attempt <= MAX_PARSE_RETRIES; attempt += 1) {
+        const response = await brain.client.generateText({
+          model: brain.model,
+          systemPrompt: buildSystemPrompt(agent, task, request, allowedTools),
+          messages,
+          ...typeof brain.settings.temperature === "number" ? {
+            temperature: brain.settings.temperature
+          } : {},
+          ...typeof brain.settings.maxTokens === "number" ? {
+            maxTokens: brain.settings.maxTokens
+          } : {}
+        });
+        responseText = response.text;
+        try {
+          parsedAction = actionSchema.parse(extractJsonObject(response.text));
+          break;
+        } catch (error) {
+          if (attempt === MAX_PARSE_RETRIES) {
+            throw error;
+          }
+          messages.push({
+            role: "assistant",
+            content: response.text
+          });
+          messages.push({
+            role: "user",
+            content: [
+              "Your previous response was invalid.",
+              error instanceof Error ? error.message : String(error),
+              "Return exactly one valid JSON object matching the required action schema."
+            ].join("\n")
+          });
+        }
+      }
+      if (!parsedAction) {
+        throw new Error("Model did not return a valid action.");
+      }
+      const transcriptEntry = {
+        step,
+        response: responseText,
+        parsedAction
+      };
+      messages.push({
+        role: "assistant",
+        content: JSON.stringify(parsedAction)
+      });
+      if (parsedAction.type === "finish") {
+        if (changedWorkspace && !verifiedAfterLatestChange) {
+          transcriptEntry.runtimeNote = "Finish rejected because code changed without a successful verification step.";
+          transcript.push(transcriptEntry);
+          messages.push({
+            role: "user",
+            content: [
+              "You tried to finish after making code changes without a successful verification step.",
+              "Run tests.run or a build/lint/test shell command, inspect failures, and only finish after verification passes."
+            ].join("\n")
+          });
+          continue;
+        }
+        const transcriptPath2 = await writeTranscriptArtifact(request.cwd, sessionId, task.id, transcript.concat(transcriptEntry));
+        artifacts.add(transcriptPath2);
+        return {
+          status: "completed",
+          summary: parsedAction.summary,
+          toolResults,
+          artifacts: Array.from(artifacts)
+        };
+      }
+      if (parsedAction.type === "block") {
+        const transcriptPath2 = await writeTranscriptArtifact(request.cwd, sessionId, task.id, transcript.concat(transcriptEntry));
+        artifacts.add(transcriptPath2);
+        return {
+          status: "blocked",
+          summary: parsedAction.reason,
+          toolResults,
+          artifacts: Array.from(artifacts)
+        };
+      }
+      if (!allowedTools.includes(parsedAction.tool)) {
+        transcriptEntry.runtimeNote = `Rejected disallowed tool "${parsedAction.tool}" for ${agent.role}.`;
+        transcript.push(transcriptEntry);
+        messages.push({
+          role: "user",
+          content: [
+            `The tool "${parsedAction.tool}" is not allowed for ${agent.role}.`,
+            `Choose one of the allowed tools instead: ${allowedTools.join(", ")}.`
+          ].join("\n")
+        });
+        continue;
+      }
+      if (isVerificationAction(parsedAction) && repairRequiredBeforeVerification && !repairAppliedSinceFailure) {
+        transcriptEntry.runtimeNote = "Verification rerun rejected because no repair action succeeded after the last failed verification.";
+        transcript.push(transcriptEntry);
+        messages.push({
+          role: "user",
+          content: [
+            "Verification already failed for this task.",
+            "Inspect the failure output, apply a repair, and only then rerun verification.",
+            lastVerificationFailure ? `Latest failure summary: ${lastVerificationFailure.summary}` : "Latest failure summary: unavailable."
+          ].join("\n")
+        });
+        continue;
+      }
+      const result = await this.toolRuntime.run(parsedAction.tool, parsedAction.input, { cwd: request.cwd }).catch((error) => createToolFailureResult(parsedAction.tool, error));
+      const mutatingAction = isMutatingAction(parsedAction);
+      const verificationAction = isVerificationAction(parsedAction);
+      if (mutatingAction && result.success) {
+        changedWorkspace = true;
+        verifiedAfterLatestChange = false;
+        if (repairRequiredBeforeVerification) {
+          repairAppliedSinceFailure = true;
+        }
+      }
+      if (verificationAction) {
+        verifiedAfterLatestChange = result.success;
+        if (result.success) {
+          verificationFailures = 0;
+          repairRequiredBeforeVerification = false;
+          repairAppliedSinceFailure = false;
+          lastVerificationFailure = null;
+        } else {
+          verificationFailures += 1;
+          repairRequiredBeforeVerification = true;
+          repairAppliedSinceFailure = false;
+          lastVerificationFailure = result;
+        }
+      }
+      transcriptEntry.toolResult = result;
+      transcript.push(transcriptEntry);
+      toolResults.push(result);
+      for (const artifact of result.artifacts) {
+        artifacts.add(artifact);
+      }
+      const followUp = [
+        buildToolResultUserMessage(step, result)
+      ];
+      if (mutatingAction && result.success) {
+        followUp.push("Code or workspace state changed. Inspect the diff if needed and run verification before finishing.");
+      }
+      if (verificationAction && !result.success) {
+        transcriptEntry.runtimeNote = [
+          `Verification failed (${verificationFailures}/${maxRepairAttempts} repair attempts used).`,
+          "Executor requires a repair action before the next verification run."
+        ].join(" ");
+        followUp.push(`Verification failed. Inspect the failure output, repair the issue, and run verification again before finishing. Repair attempts used: ${verificationFailures}/${maxRepairAttempts}.`);
+        if (verificationFailures >= maxRepairAttempts) {
+          transcriptEntry.runtimeNote = [
+            transcriptEntry.runtimeNote,
+            "Repair budget exhausted; task escalated as blocked."
+          ].join(" ");
+          const transcriptPath2 = await writeTranscriptArtifact(request.cwd, sessionId, task.id, transcript);
+          artifacts.add(transcriptPath2);
+          if (task.agentRole !== "test-debugger") {
+            return {
+              status: "handoff",
+              summary: `Verification failed ${verificationFailures} time${verificationFailures === 1 ? "" : "s"} for ${task.id}; handing off to test-debugger.`,
+              toolResults,
+              artifacts: Array.from(artifacts)
+            };
+          }
+          return {
+            status: "blocked",
+            summary: `Verification failed ${verificationFailures} time${verificationFailures === 1 ? "" : "s"} for ${task.id}; repair budget exhausted.`,
+            toolResults,
+            artifacts: Array.from(artifacts)
+          };
+        }
+      }
+      messages.push({
+        role: "user",
+        content: followUp.join("\n\n")
       });
-      executedTasks += 1;
     }
-    const postLimitEnvelope = this.buildEnvelope(session.request, workingPlan, session.id);
-    if (postLimitEnvelope.readyTasks.length > 0) {
-      notes = maybeAppendNote(notes, `Auto execution limit reached after ${executedTasks} task${executedTasks === 1 ? "" : "s"}.`);
+    const transcriptPath = await writeTranscriptArtifact(request.cwd, sessionId, task.id, transcript);
+    artifacts.add(transcriptPath);
+    return {
+      status: "paused",
+      summary: `Autonomous executor reached the step limit (${maxSteps}) for ${task.id}.`,
+      toolResults,
+      artifacts: Array.from(artifacts)
+    };
+  }
+};
+
+// ../agent-runtime/dist/orchestrator.js
+var import_promises6 = require("node:fs/promises");
+var import_node_path6 = __toESM(require("node:path"), 1);
+
+// ../tools/dist/types.js
+var ToolPermissionSchema = external_exports.enum([
+  "safe",
+  "approval-required",
+  "destructive"
+]);
+var ToolDescriptorSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  description: external_exports.string().min(1),
+  permission: ToolPermissionSchema.default("safe"),
+  timeoutMs: external_exports.number().int().positive(),
+  retryable: external_exports.boolean().default(false),
+  producesArtifacts: external_exports.boolean().default(false),
+  allowedRoles: external_exports.array(AgentRoleSchema).default([])
+});
+
+// ../tools/dist/registry.js
+var BUILTIN_TOOLS = [
+  {
+    id: "file.read",
+    description: "Read a file from the workspace.",
+    permission: "safe",
+    timeoutMs: 5e3,
+    retryable: false,
+    producesArtifacts: false,
+    allowedRoles: [
+      "session-orchestrator",
+      "repo-analyst",
+      "planner",
+      "execution-manager",
+      "frontend-specialist",
+      "backend-specialist",
+      "database-specialist",
+      "infra-specialist",
+      "test-debugger",
+      "reviewer",
+      "integrator"
+    ]
+  },
+  {
+    id: "file.list",
+    description: "List workspace files, optionally filtered by a path or pattern.",
+    permission: "safe",
+    timeoutMs: 1e4,
+    retryable: true,
+    producesArtifacts: false,
+    allowedRoles: [
+      "session-orchestrator",
+      "repo-analyst",
+      "planner",
+      "execution-manager",
+      "frontend-specialist",
+      "backend-specialist",
+      "database-specialist",
+      "infra-specialist",
+      "test-debugger",
+      "reviewer",
+      "integrator"
+    ]
+  },
+  {
+    id: "file.search",
+    description: "Search workspace file contents for a text or regex pattern.",
+    permission: "safe",
+    timeoutMs: 15e3,
+    retryable: true,
+    producesArtifacts: false,
+    allowedRoles: [
+      "session-orchestrator",
+      "repo-analyst",
+      "planner",
+      "execution-manager",
+      "frontend-specialist",
+      "backend-specialist",
+      "database-specialist",
+      "infra-specialist",
+      "test-debugger",
+      "reviewer",
+      "integrator"
+    ]
+  },
+  {
+    id: "file.write",
+    description: "Write or replace a file in the workspace.",
+    permission: "approval-required",
+    timeoutMs: 1e4,
+    retryable: true,
+    producesArtifacts: true,
+    allowedRoles: [
+      "frontend-specialist",
+      "backend-specialist",
+      "database-specialist",
+      "infra-specialist",
+      "test-debugger",
+      "integrator"
+    ]
+  },
+  {
+    id: "file.patch",
+    description: "Apply a structured patch to workspace files.",
+    permission: "approval-required",
+    timeoutMs: 1e4,
+    retryable: true,
+    producesArtifacts: true,
+    allowedRoles: [
+      "frontend-specialist",
+      "backend-specialist",
+      "database-specialist",
+      "infra-specialist",
+      "test-debugger",
+      "integrator"
+    ]
+  },
+  {
+    id: "shell.exec",
+    description: "Run a shell command inside the workspace.",
+    permission: "approval-required",
+    timeoutMs: 12e4,
+    retryable: true,
+    producesArtifacts: true,
+    allowedRoles: [
+      "repo-analyst",
+      "execution-manager",
+      "backend-specialist",
+      "infra-specialist",
+      "test-debugger",
+      "reviewer",
+      "integrator"
+    ]
+  },
+  {
+    id: "git.status",
+    description: "Inspect the current git working tree and diff state.",
+    permission: "safe",
+    timeoutMs: 1e4,
+    retryable: true,
+    producesArtifacts: false,
+    allowedRoles: [
+      "session-orchestrator",
+      "repo-analyst",
+      "execution-manager",
+      "reviewer",
+      "integrator"
+    ]
+  },
+  {
+    id: "git.diff",
+    description: "Inspect the current git diff, optionally scoped to a file path.",
+    permission: "safe",
+    timeoutMs: 15e3,
+    retryable: true,
+    producesArtifacts: false,
+    allowedRoles: [
+      "session-orchestrator",
+      "repo-analyst",
+      "execution-manager",
+      "frontend-specialist",
+      "backend-specialist",
+      "database-specialist",
+      "infra-specialist",
+      "test-debugger",
+      "reviewer",
+      "integrator"
+    ]
+  },
+  {
+    id: "tests.run",
+    description: "Execute verification commands such as tests, linting, and builds.",
+    permission: "approval-required",
+    timeoutMs: 3e5,
+    retryable: true,
+    producesArtifacts: true,
+    allowedRoles: [
+      "frontend-specialist",
+      "backend-specialist",
+      "database-specialist",
+      "infra-specialist",
+      "execution-manager",
+      "test-debugger",
+      "reviewer",
+      "integrator"
+    ]
+  }
+];
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  constructor(seed = BUILTIN_TOOLS) {
+    for (const descriptor of seed) {
+      const normalized = ToolDescriptorSchema.parse(descriptor);
+      this.tools.set(normalized.id, normalized);
     }
-    return this.createSessionSnapshot(postLimitEnvelope, {
-      startedAt: session.startedAt,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      notes,
-      events
-    });
   }
-  selectAgentsForTasks(tasks) {
-    const roles = new Set(tasks.map((task) => task.agentRole));
-    return Array.from(roles).map((role) => AGENT_CATALOG[role]).sort((left, right) => left.role.localeCompare(right.role));
+  list() {
+    return Array.from(this.tools.values()).sort((left, right) => left.id.localeCompare(right.id));
   }
-  toolsForAgent(role) {
-    return this.toolRegistry.byRole(role);
+  get(id) {
+    return this.tools.get(id);
   }
-  canAutoExecuteTask(task) {
-    return task.agentRole === "repo-analyst" || task.agentRole === "planner";
+  byRole(role) {
+    return this.list().filter((tool) => tool.allowedRoles.includes(role));
   }
-  async executeTask(sessionId, task, request, plan) {
-    if (task.agentRole === "repo-analyst") {
-      return this.executeRepoAnalysisTask(sessionId, task, request);
-    }
-    if (task.agentRole === "planner") {
-      return this.executePlannerTask(sessionId, task, request, plan);
+};
+function createDefaultToolRegistry() {
+  return new ToolRegistry(BUILTIN_TOOLS);
+}
+
+// ../tools/dist/runtime.js
+var import_promises5 = require("node:fs/promises");
+var import_node_path5 = __toESM(require("node:path"), 1);
+var import_node_process = __toESM(require("node:process"), 1);
+var import_node_child_process = require("node:child_process");
+var import_node_os = require("node:os");
+var DEFAULT_CAPTURE_LIMIT = 16e3;
+var DEFAULT_IGNORE_GLOBS = [
+  "!**/node_modules/**",
+  "!**/.git/**",
+  "!**/.kimbho/**",
+  "!**/dist/**",
+  "!**/build/**",
+  "!**/.next/**"
+];
+var DEFAULT_IGNORE_SEGMENTS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".kimbho",
+  "dist",
+  "build",
+  ".next"
+]);
+function parseLimitValue(value, fallback) {
+  if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+    return value;
+  }
+  if (typeof value === "string") {
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isInteger(parsed) && parsed > 0) {
+      return parsed;
     }
-    return {
-      status: "blocked",
-      summary: `Task ${task.id} is ready, but no executor is available for ${task.agentRole}.`,
-      toolResults: [],
-      artifacts: []
-    };
   }
-  async executeRepoAnalysisTask(sessionId, task, request) {
-    const context = { cwd: request.cwd };
-    const toolResults = await Promise.all([
-      this.safeRunTool("git.status", {}, context),
-      this.safeRunTool("file.read", { path: "package.json" }, context),
-      this.safeRunTool("file.read", { path: "README.md" }, context)
-    ]);
-    const successfulResults = toolResults.filter((result) => result.success);
-    const scripts = extractPackageScripts(successfulResults);
-    const artifactPath = await this.writeLogArtifact(sessionId, "repo-analysis", request.cwd, [
-      `# Repo Analysis`,
-      ``,
-      `Goal: ${request.goal}`,
-      `Workspace: ${request.cwd}`,
-      `Task: ${task.id} - ${task.title}`,
-      ``,
-      `## Observations`,
-      `- Successful tool probes: ${successfulResults.length}/${toolResults.length}`,
-      `- Workspace state: ${request.workspaceState}`,
-      `- Detected scripts: ${scripts.length > 0 ? scripts.join(", ") : "none"}`,
-      ``,
-      renderToolResultSection(toolResults)
-    ].join("\n"));
-    return {
-      status: "completed",
-      summary: `Completed ${task.id}: captured repo analysis and saved ${import_node_path4.default.basename(artifactPath)}.`,
-      toolResults,
-      artifacts: [
-        artifactPath
-      ]
-    };
+  return fallback;
+}
+function truncateOutput(value) {
+  if (!value) {
+    return value;
   }
-  async executePlannerTask(sessionId, task, request, plan) {
-    const artifactPath = await this.writeLogArtifact(sessionId, "architecture-brief", request.cwd, [
-      `# Architecture Brief`,
-      ``,
-      `Goal: ${request.goal}`,
-      `Summary: ${plan.summary}`,
-      `Repo Strategy: ${plan.repoStrategy.mode} - ${plan.repoStrategy.reasoning}`,
-      ``,
-      `## Assumptions`,
-      ...plan.assumptions.map((assumption) => `- ${assumption}`),
-      ``,
-      `## Milestones`,
-      ...plan.milestones.flatMap((milestone) => [
-        `### ${milestone.title}`,
-        milestone.objective,
-        ...milestone.tasks.map((milestoneTask) => `- ${milestoneTask.id}: ${milestoneTask.title} [${milestoneTask.agentRole}]`),
-        ``
-      ]),
-      `## Verification`,
-      ...plan.verificationChecklist.map((item) => `- ${item}`)
-    ].join("\n"));
-    return {
-      status: "completed",
-      summary: `Completed ${task.id}: wrote architecture brief ${import_node_path4.default.basename(artifactPath)}.`,
-      toolResults: [],
-      artifacts: [
-        artifactPath
-      ]
-    };
+  if (value.length <= DEFAULT_CAPTURE_LIMIT) {
+    return value;
   }
-  async safeRunTool(toolId, input, context) {
+  const omitted = value.length - DEFAULT_CAPTURE_LIMIT;
+  return `${value.slice(0, DEFAULT_CAPTURE_LIMIT)}
+... [truncated ${omitted} chars]`;
+}
+function isIgnoredWorkspacePath(value) {
+  const normalized = value.replace(/\\/g, "/");
+  const segments = normalized.split("/");
+  return segments.some((segment) => DEFAULT_IGNORE_SEGMENTS.has(segment));
+}
+function extractPatchArtifacts(cwd, patch) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const line of patch.split("\n")) {
+    if (!line.startsWith("+++ ") && !line.startsWith("--- ")) {
+      continue;
+    }
+    const raw = line.slice(4).trim();
+    if (!raw || raw === "/dev/null") {
+      continue;
+    }
+    const normalized = raw.startsWith("a/") || raw.startsWith("b/") ? raw.slice(2) : raw;
     try {
-      return await this.toolRuntime.run(toolId, input, context);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return {
-        toolId,
-        success: false,
-        summary: `${toolId} failed: ${message}`,
-        stderr: message,
-        artifacts: []
-      };
+      paths.add(resolveWorkspacePath(cwd, normalized));
+    } catch {
+      continue;
     }
   }
-  async writeLogArtifact(sessionId, label, cwd, content) {
-    await ensureKimbhoDir(cwd);
-    const logsDir = import_node_path4.default.join(resolveKimbhoDir(cwd), "logs");
-    const outputPath = import_node_path4.default.join(logsDir, `${sessionId}-${label}.md`);
-    await (0, import_promises4.writeFile)(outputPath, `${content}
-`, "utf8");
-    return outputPath;
+  return Array.from(paths);
+}
+function resolveWorkspacePath(cwd, filePath) {
+  const resolved = import_node_path5.default.resolve(cwd, filePath);
+  const relative = import_node_path5.default.relative(cwd, resolved);
+  if (relative.startsWith("..") || import_node_path5.default.isAbsolute(relative)) {
+    throw new Error(`Path "${filePath}" escapes the workspace.`);
   }
-};
-
-// src/commands/agents.ts
-function createAgentsCommand() {
-  return new Command("agents").description("Show the current agent hierarchy and allowed tools.").option("--active", "Show only agents assigned to the latest session", false).action(async (options) => {
-    const orchestrator = new ExecutionOrchestrator();
-    const session = options.active ? await loadLatestSession(process.cwd()) : null;
-    const profiles = session ? listAgentProfiles().filter((agent) => session.assignedAgents.includes(agent.role)) : listAgentProfiles();
-    if (session) {
-      console.log(`Session: ${session.id}`);
-      console.log(`Ready tasks: ${session.readyTaskIds.join(", ") || "none"}`);
-      console.log(`Blocked tasks: ${session.blockedTaskIds.join(", ") || "none"}`);
-    }
-    for (const agent of profiles) {
-      const tools = orchestrator.toolsForAgent(agent.role).map((tool) => tool.id);
-      console.log(`${agent.role}`);
-      console.log(`  brain: ${agent.brainRole}`);
-      console.log(`  purpose: ${agent.purpose}`);
-      console.log(`  tools: ${tools.join(", ")}`);
-      console.log(`  concurrency: ${agent.maxConcurrentTasks}`);
+  return resolved;
+}
+async function runSpawn(command, args, cwd, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const child = (0, import_node_child_process.spawn)(command, args, {
+      cwd,
+      env: import_node_process.default.env,
+      stdio: [
+        "ignore",
+        "pipe",
+        "pipe"
+      ]
+    });
+    const stdout = [];
+    const stderr = [];
+    let settled = false;
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => child.kill("SIGKILL"), 1e3).unref();
+    }, timeoutMs);
+    child.stdout.on("data", (chunk) => {
+      stdout.push(String(chunk));
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr.push(String(chunk));
+    });
+    child.on("error", (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolve({
+        code,
+        stdout: stdout.join(""),
+        stderr: stderr.join(""),
+        timedOut
+      });
+    });
+  });
+}
+async function runShellCommand(toolId, command, cwd, timeoutMs) {
+  const shell = import_node_process.default.env.SHELL ?? "/bin/sh";
+  const result = await runSpawn(shell, [
+    "-lc",
+    command
+  ], cwd, timeoutMs);
+  const success = !result.timedOut && result.code === 0;
+  const summary = result.timedOut ? `Command timed out after ${timeoutMs}ms.` : success ? `Command completed successfully.` : `Command exited with code ${result.code ?? "unknown"}.`;
+  return ToolResultSchema.parse({
+    toolId,
+    success,
+    summary,
+    stdout: truncateOutput(result.stdout),
+    stderr: truncateOutput(result.stderr)
+  });
+}
+async function executeFileRead(input, context) {
+  const rawPath = typeof input.path === "string" ? input.path : null;
+  if (!rawPath) {
+    throw new Error("file.read requires a string path.");
+  }
+  const targetPath = resolveWorkspacePath(context.cwd, rawPath);
+  const contents = await (0, import_promises5.readFile)(targetPath, "utf8");
+  return ToolResultSchema.parse({
+    toolId: "file.read",
+    success: true,
+    summary: `Read ${import_node_path5.default.relative(context.cwd, targetPath) || import_node_path5.default.basename(targetPath)}.`,
+    stdout: truncateOutput(contents),
+    artifacts: [
+      targetPath
+    ]
+  });
+}
+async function executeFileList(input, context, timeoutMs) {
+  const root = typeof input.path === "string" && input.path.trim().length > 0 ? input.path : ".";
+  const pattern = typeof input.pattern === "string" && input.pattern.trim().length > 0 ? input.pattern : null;
+  const limit = parseLimitValue(input.limit, 200);
+  const searchRoot = resolveWorkspacePath(context.cwd, root);
+  const relativeRoot = import_node_path5.default.relative(context.cwd, searchRoot) || ".";
+  const rootArg = relativeRoot === "." ? "." : relativeRoot;
+  let result;
+  try {
+    result = await runSpawn("rg", [
+      "--files",
+      ...DEFAULT_IGNORE_GLOBS.flatMap((glob) => [
+        "-g",
+        glob
+      ]),
+      rootArg
+    ], context.cwd, timeoutMs);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!message.includes("ENOENT")) {
+      throw error;
     }
+    result = await runSpawn("find", [
+      rootArg,
+      "-type",
+      "f"
+    ], context.cwd, timeoutMs);
+  }
+  const lines = result.stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !isIgnoredWorkspacePath(line));
+  const filtered = pattern ? lines.filter((line) => line.toLowerCase().includes(pattern.toLowerCase())) : lines;
+  const sliced = filtered.slice(0, limit);
+  const success = !result.timedOut && result.code === 0;
+  return ToolResultSchema.parse({
+    toolId: "file.list",
+    success,
+    summary: success ? `Listed ${sliced.length} file${sliced.length === 1 ? "" : "s"} from ${rootArg}.` : result.timedOut ? `File listing timed out after ${timeoutMs}ms.` : `File listing failed with code ${result.code ?? "unknown"}.`,
+    stdout: sliced.join("\n"),
+    stderr: truncateOutput(result.stderr)
   });
 }
-
-// src/commands/brains.ts
-var import_node_process2 = __toESM(require("node:process"), 1);
-
-// ../brains/dist/templates.js
-var BUILTIN_PROVIDER_TEMPLATES = [
-  {
-    id: "openai",
-    label: "OpenAI",
-    driver: "openai-responses",
-    defaultBaseUrl: "https://api.openai.com/v1",
-    defaultApiKeyEnv: "OPENAI_API_KEY",
-    defaultModel: "gpt-5",
-    notes: "Uses the OpenAI Responses API."
-  },
-  {
-    id: "anthropic",
-    label: "Anthropic",
-    driver: "anthropic-messages",
-    defaultBaseUrl: "https://api.anthropic.com/v1/messages",
-    defaultApiKeyEnv: "ANTHROPIC_API_KEY",
-    notes: "Uses the Anthropic Messages API."
-  },
-  {
-    id: "openrouter",
-    label: "OpenRouter",
-    driver: "openai-compatible",
-    defaultBaseUrl: "https://openrouter.ai/api/v1",
-    defaultApiKeyEnv: "OPENROUTER_API_KEY",
-    notes: "Routes through the OpenAI-compatible OpenRouter API."
-  },
-  {
-    id: "ollama",
-    label: "Ollama",
-    driver: "ollama",
-    defaultBaseUrl: "http://localhost:11434",
-    defaultModel: "qwen2.5-coder:7b",
-    notes: "Runs against a local Ollama server."
-  },
-  {
-    id: "lmstudio",
-    label: "LM Studio",
-    driver: "openai-compatible",
-    defaultBaseUrl: "http://localhost:1234/v1",
-    notes: "Works with LM Studio's local OpenAI-compatible server."
+async function executeFileSearch(input, context, timeoutMs) {
+  const pattern = typeof input.pattern === "string" ? input.pattern.trim() : "";
+  const root = typeof input.path === "string" && input.path.trim().length > 0 ? input.path : ".";
+  const limit = parseLimitValue(input.limit, 50);
+  if (!pattern) {
+    throw new Error("file.search requires a non-empty pattern.");
+  }
+  const searchRoot = resolveWorkspacePath(context.cwd, root);
+  const relativeRoot = import_node_path5.default.relative(context.cwd, searchRoot) || ".";
+  const rootArg = relativeRoot === "." ? "." : relativeRoot;
+  let result;
+  try {
+    result = await runSpawn("rg", [
+      "-n",
+      "--no-heading",
+      "--color",
+      "never",
+      "--max-columns",
+      "240",
+      ...DEFAULT_IGNORE_GLOBS.flatMap((glob) => [
+        "-g",
+        glob
+      ]),
+      pattern,
+      rootArg
+    ], context.cwd, timeoutMs);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (!message.includes("ENOENT")) {
+      throw error;
+    }
+    result = await runSpawn("grep", [
+      "-R",
+      "-n",
+      pattern,
+      rootArg
+    ], context.cwd, timeoutMs);
   }
-];
-function listProviderTemplates() {
-  return BUILTIN_PROVIDER_TEMPLATES.slice().sort((left, right) => left.id.localeCompare(right.id));
-}
-function findProviderTemplate(templateId) {
-  return BUILTIN_PROVIDER_TEMPLATES.find((template) => template.id === templateId);
+  const isNoMatch = result.code === 1 && !result.timedOut;
+  const lines = result.stdout.split("\n").map((line) => line.trimEnd()).filter((line) => line.length > 0 && !isIgnoredWorkspacePath(line)).slice(0, limit);
+  const success = !result.timedOut && result.code === 0 || isNoMatch;
+  return ToolResultSchema.parse({
+    toolId: "file.search",
+    success,
+    summary: isNoMatch ? `No matches found for "${pattern}" in ${rootArg}.` : success ? `Found ${lines.length} match${lines.length === 1 ? "" : "es"} for "${pattern}" in ${rootArg}.` : result.timedOut ? `File search timed out after ${timeoutMs}ms.` : `File search failed with code ${result.code ?? "unknown"}.`,
+    stdout: lines.join("\n"),
+    stderr: truncateOutput(result.stderr)
+  });
 }
-function buildProviderFromTemplate(templateId, options = {}) {
-  const template = findProviderTemplate(templateId);
-  if (!template) {
-    throw new Error(`Unknown provider template "${templateId}".`);
+async function executeFileWrite(input, context) {
+  const rawPath = typeof input.path === "string" ? input.path : null;
+  const content = typeof input.content === "string" ? input.content : null;
+  if (!rawPath) {
+    throw new Error("file.write requires a string path.");
   }
-  return ProviderDefinitionSchema.parse({
-    id: options.providerId ?? template.id,
-    label: options.label ?? template.label,
-    driver: template.driver,
-    ...options.baseUrl ?? template.defaultBaseUrl ? {
-      baseUrl: options.baseUrl ?? template.defaultBaseUrl
-    } : {},
-    ...options.apiKeyEnv ?? template.defaultApiKeyEnv ? {
-      apiKeyEnv: options.apiKeyEnv ?? template.defaultApiKeyEnv
-    } : {},
-    ...options.model ?? template.defaultModel ? {
-      defaultModel: options.model ?? template.defaultModel
-    } : {},
-    ...options.models && options.models.length > 0 ? {
-      models: options.models
-    } : {}
+  if (content === null) {
+    throw new Error("file.write requires a string content field.");
+  }
+  const targetPath = resolveWorkspacePath(context.cwd, rawPath);
+  let existed = true;
+  try {
+    await (0, import_promises5.access)(targetPath);
+  } catch {
+    existed = false;
+  }
+  await (0, import_promises5.mkdir)(import_node_path5.default.dirname(targetPath), { recursive: true });
+  await (0, import_promises5.writeFile)(targetPath, content, "utf8");
+  return ToolResultSchema.parse({
+    toolId: "file.write",
+    success: true,
+    summary: `${existed ? "Updated" : "Created"} ${import_node_path5.default.relative(context.cwd, targetPath) || import_node_path5.default.basename(targetPath)}.`,
+    artifacts: [
+      targetPath
+    ]
   });
 }
-
-// ../brains/dist/registry.js
-var import_promises5 = require("node:fs/promises");
-var import_node_path5 = __toESM(require("node:path"), 1);
-var import_node_url = require("node:url");
-function resolveApiKey(definition) {
-  if (!definition.apiKeyEnv) {
-    return null;
+async function executeShell(input, context, timeoutMs) {
+  const command = typeof input.command === "string" ? input.command : null;
+  if (!command) {
+    throw new Error("shell.exec requires a command string.");
   }
-  return process.env[definition.apiKeyEnv] ?? null;
+  return runShellCommand("shell.exec", command, context.cwd, timeoutMs);
 }
-function makeAbortSignal(timeoutMs) {
-  const controller = new AbortController();
-  setTimeout(() => controller.abort(), timeoutMs).unref?.();
-  return controller.signal;
+async function executeGitStatus(_input, context, timeoutMs) {
+  return runShellCommand("git.status", "git status --short --branch", context.cwd, timeoutMs);
 }
-async function requestJson(url, init, timeoutMs = 3e4) {
-  const response = await fetch(url, {
-    ...init,
-    signal: makeAbortSignal(timeoutMs)
+async function executeGitDiff(input, context, timeoutMs) {
+  const rawPath = typeof input.path === "string" && input.path.trim().length > 0 ? input.path : null;
+  const args = [
+    "diff",
+    "--no-ext-diff",
+    "--stat",
+    "--patch",
+    "--unified=3"
+  ];
+  if (rawPath) {
+    const targetPath = resolveWorkspacePath(context.cwd, rawPath);
+    const relativeTarget = import_node_path5.default.relative(context.cwd, targetPath) || ".";
+    args.push("--", relativeTarget);
+  }
+  const repoProbe = await runSpawn("git", [
+    "rev-parse",
+    "--is-inside-work-tree"
+  ], context.cwd, timeoutMs);
+  if (repoProbe.code !== 0 || repoProbe.stdout.trim() !== "true") {
+    return ToolResultSchema.parse({
+      toolId: "git.diff",
+      success: false,
+      summary: "git diff unavailable because the workspace is not a git repository.",
+      stderr: "Not a git repository.",
+      artifacts: []
+    });
+  }
+  const result = await runSpawn("git", args, context.cwd, timeoutMs);
+  const isClean = result.code === 0 && result.stdout.trim().length === 0;
+  const success = !result.timedOut && (result.code === 0 || isClean);
+  return ToolResultSchema.parse({
+    toolId: "git.diff",
+    success,
+    summary: isClean ? "No git diff changes detected." : success ? `Captured git diff${rawPath ? ` for ${rawPath}` : ""}.` : result.timedOut ? `git diff timed out after ${timeoutMs}ms.` : `git diff failed with code ${result.code ?? "unknown"}.`,
+    stdout: truncateOutput(result.stdout),
+    stderr: truncateOutput(result.stderr)
   });
-  if (!response.ok) {
-    throw new Error(`Request failed with ${response.status} ${response.statusText}`);
+}
+async function executeTests(input, context, timeoutMs) {
+  const command = typeof input.command === "string" && input.command.trim().length > 0 ? input.command : "npm test";
+  const result = await runShellCommand("tests.run", command, context.cwd, timeoutMs);
+  return ToolResultSchema.parse({
+    ...result,
+    summary: result.success ? `Verification command passed: ${command}` : `Verification command failed: ${command}`
+  });
+}
+async function executeFilePatch(input, context, timeoutMs) {
+  const patch = typeof input.patch === "string" ? input.patch : null;
+  if (!patch) {
+    throw new Error("file.patch requires a unified diff in the patch field.");
+  }
+  const tempDir = await (0, import_promises5.mkdtemp)(import_node_path5.default.join((0, import_node_os.tmpdir)(), "kimbho-patch-"));
+  const patchPath = import_node_path5.default.join(tempDir, "change.patch");
+  try {
+    await (0, import_promises5.writeFile)(patchPath, patch, "utf8");
+    const result = await runSpawn("git", [
+      "apply",
+      "--recount",
+      "--whitespace=nowarn",
+      patchPath
+    ], context.cwd, timeoutMs);
+    const success = !result.timedOut && result.code === 0;
+    return ToolResultSchema.parse({
+      toolId: "file.patch",
+      success,
+      summary: success ? "Patch applied successfully." : result.timedOut ? `Patch timed out after ${timeoutMs}ms.` : `Patch failed with code ${result.code ?? "unknown"}.`,
+      stdout: truncateOutput(result.stdout),
+      stderr: truncateOutput(result.stderr),
+      artifacts: extractPatchArtifacts(context.cwd, patch)
+    });
+  } finally {
+    await (0, import_promises5.rm)(tempDir, { recursive: true, force: true });
   }
-  return response.json();
 }
-function trimTrailingSlash(value) {
-  return value.replace(/\/+$/, "");
+var ToolRuntime = class {
+  registry;
+  executors;
+  constructor(registry = createDefaultToolRegistry()) {
+    this.registry = registry;
+    this.executors = /* @__PURE__ */ new Map([
+      [
+        "file.read",
+        (input, context) => executeFileRead(input, context)
+      ],
+      [
+        "file.list",
+        executeFileList
+      ],
+      [
+        "file.search",
+        executeFileSearch
+      ],
+      [
+        "file.write",
+        (input, context) => executeFileWrite(input, context)
+      ],
+      [
+        "file.patch",
+        executeFilePatch
+      ],
+      [
+        "shell.exec",
+        executeShell
+      ],
+      [
+        "git.status",
+        executeGitStatus
+      ],
+      [
+        "git.diff",
+        executeGitDiff
+      ],
+      [
+        "tests.run",
+        executeTests
+      ]
+    ]);
+  }
+  async run(toolId, input, context) {
+    const descriptor = this.registry.get(toolId);
+    if (!descriptor) {
+      throw new Error(`Unknown tool "${toolId}".`);
+    }
+    const executor = this.executors.get(toolId);
+    if (!executor) {
+      throw new Error(`No executor registered for "${toolId}".`);
+    }
+    return executor(input, context, descriptor.timeoutMs);
+  }
+};
+
+// ../agent-runtime/dist/orchestrator.js
+function createSessionId() {
+  return `session-${Date.now()}`;
 }
-function joinUrl(baseUrl, suffix) {
-  const normalizedBase = trimTrailingSlash(baseUrl);
-  const normalizedSuffix = suffix.startsWith("/") ? suffix : `/${suffix}`;
-  return `${normalizedBase}${normalizedSuffix}`;
+function createEventId(type, taskId) {
+  return `${type}-${taskId ?? "session"}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 }
-function isOpenRouter(definition) {
-  return definition.baseUrl?.includes("openrouter.ai") ?? false;
+function isTaskReady(task, completedTaskIds) {
+  return task.status === "pending" && task.dependsOn.every((taskId) => completedTaskIds.has(taskId));
+}
+function completedTaskIdsFromPlan(plan) {
+  return new Set(flattenPlanTasks(plan).filter((task) => task.status === "completed").map((task) => task.id));
+}
+function deriveStatus(plan, readyTasks, blockedTasks) {
+  const tasks = flattenPlanTasks(plan);
+  const completed = tasks.filter((task) => task.status === "completed").length;
+  if (completed === tasks.length && tasks.length > 0) {
+    return "completed";
+  }
+  if (readyTasks.length > 0) {
+    return completed > 0 ? "running" : "ready";
+  }
+  if (blockedTasks.length > 0) {
+    return "blocked";
+  }
+  return "planned";
+}
+function updateTaskStatus(plan, taskId, status) {
+  const milestones = plan.milestones.map((milestone) => ({
+    ...milestone,
+    tasks: milestone.tasks.map((task) => task.id === taskId ? {
+      ...task,
+      status
+    } : task)
+  }));
+  return {
+    ...plan,
+    milestones
+  };
 }
-function buildProviderHeaders(definition, apiKey, includeJsonContentType = true) {
-  const headers = {
-    ...definition.headers
+function replaceTask(plan, taskId, mapper) {
+  const milestones = plan.milestones.map((milestone) => ({
+    ...milestone,
+    tasks: milestone.tasks.map((task) => task.id === taskId ? mapper(task) : task)
+  }));
+  return {
+    ...plan,
+    milestones
   };
-  if (includeJsonContentType) {
-    headers["content-type"] = "application/json";
-  }
-  if (apiKey) {
-    headers.authorization = `Bearer ${apiKey}`;
-  }
-  if (isOpenRouter(definition)) {
-    const siteUrl = process.env.OPENROUTER_SITE_URL;
-    const appName = process.env.OPENROUTER_APP_NAME ?? "Kimbho CLI";
-    if (siteUrl) {
-      headers["HTTP-Referer"] = siteUrl;
-    }
-    headers["X-Title"] = appName;
-  }
-  return headers;
 }
-function filterModels(models, input = {}) {
-  const normalized = input.search?.trim().toLowerCase();
-  const filtered = normalized ? models.filter((model) => [model.id, model.name].filter((value) => Boolean(value)).some((value) => value.toLowerCase().includes(normalized))) : models;
-  return typeof input.limit === "number" ? filtered.slice(0, input.limit) : filtered;
+function maybeAppendNote(notes, note) {
+  return notes.at(-1) === note ? notes : [
+    ...notes,
+    note
+  ];
 }
-function mapOpenAIStyleModels(providerId, payload, input) {
-  const response = payload;
-  const data = Array.isArray(response.data) ? response.data : [];
-  const models = data.flatMap((item) => {
-    if (typeof item !== "object" || item === null) {
-      return [];
-    }
-    const record = item;
-    const pricing = typeof record.pricing === "object" && record.pricing !== null ? record.pricing : null;
-    const architecture = typeof record.architecture === "object" && record.architecture !== null ? record.architecture : null;
-    return [
-      ProviderModelSchema.parse({
-        id: String(record.id ?? ""),
-        ...typeof record.name === "string" ? {
-          name: record.name
-        } : {},
-        ...typeof record.description === "string" ? {
-          description: record.description
-        } : {},
-        ...typeof record.context_length === "number" ? {
-          contextLength: record.context_length
-        } : {},
-        ...pricing && typeof pricing.prompt === "string" ? {
-          promptPrice: pricing.prompt
-        } : {},
-        ...pricing && typeof pricing.completion === "string" ? {
-          completionPrice: pricing.completion
-        } : {},
-        ...architecture && typeof architecture.modality === "string" ? {
-          modality: architecture.modality
-        } : {},
-        providerId
-      })
-    ];
-  });
-  return filterModels(models, input);
+function mergeUnique(items) {
+  return Array.from(new Set(items.filter((item) => item.trim().length > 0)));
 }
-function mapAnthropicModels(providerId, payload, input) {
-  const response = payload;
-  const data = Array.isArray(response.data) ? response.data : [];
-  const models = data.flatMap((item) => {
-    if (typeof item !== "object" || item === null) {
-      return [];
-    }
-    const record = item;
-    return [
-      ProviderModelSchema.parse({
-        id: String(record.id ?? ""),
-        ...typeof record.display_name === "string" ? {
-          name: record.display_name
-        } : {},
-        providerId
-      })
+function renderToolResultSection(results) {
+  return results.map((result) => {
+    const lines = [
+      `## ${result.toolId}`,
+      `- success: ${result.success ? "yes" : "no"}`,
+      `- summary: ${result.summary}`
     ];
-  });
-  return filterModels(models, input);
-}
-function mapOllamaModels(providerId, payload, input) {
-  const response = payload;
-  const data = Array.isArray(response.models) ? response.models : [];
-  const models = data.flatMap((item) => {
-    if (typeof item !== "object" || item === null) {
-      return [];
+    if (result.stdout) {
+      lines.push("");
+      lines.push("```text");
+      lines.push(result.stdout);
+      lines.push("```");
     }
-    const record = item;
-    const details = typeof record.details === "object" && record.details !== null ? record.details : null;
-    const id = typeof record.model === "string" ? record.model : typeof record.name === "string" ? record.name : "";
-    return [
-      ProviderModelSchema.parse({
-        id,
-        ...typeof record.name === "string" ? {
-          name: record.name
-        } : {},
-        ...details && typeof details.family === "string" ? {
-          modality: details.family
-        } : {},
-        ...details && typeof details.parameter_size === "string" ? {
-          description: details.parameter_size
-        } : {},
-        providerId
-      })
-    ];
-  });
-  return filterModels(models, input);
+    if (result.stderr) {
+      lines.push("");
+      lines.push("```text");
+      lines.push(result.stderr);
+      lines.push("```");
+    }
+    return lines.join("\n");
+  }).join("\n\n");
 }
-function toChatMessages(input) {
-  const messages = [];
-  if (input.systemPrompt) {
-    messages.push({
-      role: "system",
-      content: input.systemPrompt
-    });
+function extractPackageScripts(toolResults) {
+  const packageResult = toolResults.find((result) => result.artifacts.some((artifact) => artifact.endsWith("package.json")) && result.stdout);
+  if (!packageResult?.stdout) {
+    return [];
   }
-  if (input.messages && input.messages.length > 0) {
-    messages.push(...input.messages);
-  } else if (input.userPrompt) {
-    messages.push({
-      role: "user",
-      content: input.userPrompt
-    });
+  try {
+    const parsed = JSON.parse(packageResult.stdout);
+    return Object.keys(parsed.scripts ?? {}).sort();
+  } catch {
+    return [];
   }
-  return messages;
 }
-function toPromptText(input) {
-  const messages = toChatMessages(input);
-  return messages.map((message) => `${message.role.toUpperCase()}: ${message.content}`).join("\n\n");
+function createDebuggerHandoffTask(task, outcome) {
+  const failingResults = outcome.toolResults.filter((result) => !result.success);
+  const failureSummaries = failingResults.slice(-3).map((result) => `${result.toolId}: ${result.summary}`);
+  const artifactList = outcome.artifacts.slice(-5);
+  const handoffDescriptionParts = [
+    `Debugger handoff from ${task.agentRole}.`,
+    `Original task: ${task.title}.`,
+    `Handoff reason: ${outcome.summary}`,
+    `Inspect the recent failures, reproduce the issue, apply a targeted repair, and rerun verification before finishing.`,
+    failureSummaries.length > 0 ? `Recent failures:
+${failureSummaries.map((item) => `- ${item}`).join("\n")}` : "",
+    artifactList.length > 0 ? `Failure artifacts:
+${artifactList.map((artifact) => `- ${artifact}`).join("\n")}` : "",
+    `Original task description: ${task.description}`
+  ].filter((part) => part.length > 0);
+  return {
+    ...task,
+    title: task.title.startsWith("Debug ") ? task.title : `Debug ${task.title}`,
+    description: handoffDescriptionParts.join("\n\n"),
+    type: "verification",
+    status: "pending",
+    agentRole: "test-debugger",
+    acceptanceCriteria: mergeUnique([
+      ...task.acceptanceCriteria,
+      "The failing verification is reproduced or explicitly explained.",
+      "A targeted repair is applied or a concrete blocker is recorded.",
+      "Verification passes after the repair."
+    ]),
+    outputs: mergeUnique([
+      ...task.outputs,
+      "Debugger handoff notes",
+      "Verification evidence"
+    ]),
+    filesLikelyTouched: mergeUnique([
+      ...task.filesLikelyTouched,
+      ".kimbho/logs/"
+    ]),
+    riskLevel: "high"
+  };
 }
-function requireModel(definition, input) {
-  const model = input.model ?? definition.defaultModel;
-  if (!model) {
-    throw new Error(`Provider "${definition.id}" does not have a resolved model.`);
+var ExecutionOrchestrator = class {
+  toolRegistry;
+  toolRuntime;
+  constructor(toolRegistry = createDefaultToolRegistry(), toolRuntime = new ToolRuntime(toolRegistry)) {
+    this.toolRegistry = toolRegistry;
+    this.toolRuntime = toolRuntime;
   }
-  return model;
-}
-var OpenAIResponsesProvider = class {
-  definition;
-  constructor(definition) {
-    this.definition = ProviderDefinitionSchema.parse(definition);
+  buildEnvelope(request, plan, sessionId = createSessionId()) {
+    const tasks = flattenPlanTasks(plan);
+    const completedTaskIds = completedTaskIdsFromPlan(plan);
+    const readyTasks = tasks.filter((task) => isTaskReady(task, completedTaskIds));
+    const blockedTasks = tasks.filter((task) => task.status !== "completed" && !isTaskReady(task, completedTaskIds));
+    const assignedAgents = this.selectAgentsForTasks(readyTasks);
+    return {
+      sessionId,
+      request,
+      plan,
+      readyTasks,
+      blockedTasks,
+      assignedAgents
+    };
   }
-  async healthCheck() {
-    const apiKey = resolveApiKey(this.definition);
-    if (!apiKey) {
-      return {
-        ok: false,
-        message: `Missing ${this.definition.apiKeyEnv ?? "API key env var"}`
-      };
+  createSessionSnapshot(envelope, overrides = {}) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const status = deriveStatus(envelope.plan, envelope.readyTasks, envelope.blockedTasks);
+    return SessionSnapshotSchema.parse({
+      id: envelope.sessionId,
+      goal: envelope.request.goal,
+      cwd: envelope.request.cwd,
+      startedAt: timestamp,
+      updatedAt: timestamp,
+      status,
+      request: envelope.request,
+      plan: envelope.plan,
+      readyTaskIds: envelope.readyTasks.map((task) => task.id),
+      blockedTaskIds: envelope.blockedTasks.map((task) => task.id),
+      completedTaskIds: Array.from(completedTaskIdsFromPlan(envelope.plan)),
+      assignedAgents: envelope.assignedAgents.map((agent) => agent.role),
+      notes: [
+        "Initial session snapshot created from the current plan."
+      ],
+      events: [],
+      ...overrides
+    });
+  }
+  async continueSession(session, options = {}) {
+    let workingPlan = session.plan;
+    let notes = [
+      ...session.notes
+    ];
+    let events = [
+      ...session.events
+    ];
+    const maxAutoTasks = options.maxAutoTasks ?? 2;
+    let executedTasks = 0;
+    while (executedTasks < maxAutoTasks) {
+      const envelope = this.buildEnvelope(session.request, workingPlan, session.id);
+      const autoTask = envelope.readyTasks.find((task) => this.canAutoExecuteTask(task));
+      if (!autoTask) {
+        const nextTask = envelope.readyTasks[0];
+        if (nextTask) {
+          const note = `Execution paused at ${nextTask.id} (${nextTask.title}): no built-in executor is wired for ${nextTask.agentRole} yet.`;
+          notes = maybeAppendNote(notes, note);
+        }
+        return this.createSessionSnapshot(this.buildEnvelope(session.request, workingPlan, session.id), {
+          startedAt: session.startedAt,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          notes,
+          events
+        });
+      }
+      events.push({
+        id: createEventId("task-started", autoTask.id),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        type: "task-started",
+        taskId: autoTask.id,
+        agentRole: autoTask.agentRole,
+        message: `Started ${autoTask.id}: ${autoTask.title}`,
+        toolResults: [],
+        artifacts: []
+      });
+      const outcome = await this.executeTask(session.id, autoTask, session.request, workingPlan, options);
+      workingPlan = outcome.status === "handoff" ? replaceTask(workingPlan, autoTask.id, () => createDebuggerHandoffTask(autoTask, outcome)) : updateTaskStatus(workingPlan, autoTask.id, outcome.status === "completed" ? "completed" : outcome.status === "blocked" ? "blocked" : "pending");
+      notes = maybeAppendNote(notes, outcome.summary);
+      events.push({
+        id: createEventId(outcome.status === "completed" ? "task-completed" : outcome.status === "blocked" ? "task-blocked" : outcome.status === "handoff" ? "task-handed-off" : "task-paused", autoTask.id),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        type: outcome.status === "completed" ? "task-completed" : outcome.status === "blocked" ? "task-blocked" : outcome.status === "handoff" ? "task-handed-off" : "task-paused",
+        taskId: autoTask.id,
+        agentRole: autoTask.agentRole,
+        message: outcome.summary,
+        toolResults: outcome.toolResults,
+        artifacts: outcome.artifacts
+      });
+      executedTasks += 1;
     }
-    return {
-      ok: true,
-      message: `${this.definition.baseUrl ?? "https://api.openai.com/v1"} (${this.definition.defaultModel ?? "model not set"})`
-    };
-  }
-  async listModels(input) {
-    const apiKey = resolveApiKey(this.definition);
-    if (!apiKey) {
-      throw new Error(`Missing ${this.definition.apiKeyEnv ?? "API key env var"} for provider "${this.definition.id}".`);
+    const postLimitEnvelope = this.buildEnvelope(session.request, workingPlan, session.id);
+    if (postLimitEnvelope.readyTasks.length > 0) {
+      notes = maybeAppendNote(notes, `Auto execution limit reached after ${executedTasks} task${executedTasks === 1 ? "" : "s"}.`);
     }
-    const baseUrl = this.definition.baseUrl ?? "https://api.openai.com/v1";
-    const payload = await requestJson(joinUrl(baseUrl, "/models"), {
-      method: "GET",
-      headers: buildProviderHeaders(this.definition, apiKey, false)
+    return this.createSessionSnapshot(postLimitEnvelope, {
+      startedAt: session.startedAt,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      notes,
+      events
     });
-    return mapOpenAIStyleModels(this.definition.id, payload, input);
   }
-  async generateText(input) {
-    const apiKey = resolveApiKey(this.definition);
-    if (!apiKey) {
-      throw new Error(`Missing ${this.definition.apiKeyEnv ?? "API key env var"} for provider "${this.definition.id}".`);
-    }
-    const baseUrl = this.definition.baseUrl ?? "https://api.openai.com/v1";
-    const model = requireModel(this.definition, input);
-    const messages = toChatMessages(input).map((message) => ({
-      role: message.role,
-      content: [
-        {
-          type: "input_text",
-          text: message.content
-        }
-      ]
-    }));
-    const response = await requestJson(`${baseUrl}/responses`, {
-      method: "POST",
-      headers: {
-        ...buildProviderHeaders(this.definition, apiKey)
-      },
-      body: JSON.stringify({
-        model,
-        input: messages,
-        ...typeof input.temperature === "number" ? {
-          temperature: input.temperature
-        } : {},
-        ...typeof input.maxTokens === "number" ? {
-          max_output_tokens: input.maxTokens
-        } : {}
-      })
-    });
-    const text = typeof response.output_text === "string" ? response.output_text : Array.isArray(response.output) ? response.output.flatMap((item) => typeof item === "object" && item !== null && "content" in item && Array.isArray(item.content) ? item.content : []).flatMap((item) => typeof item === "object" && item !== null && "text" in item ? [
-      String(item.text)
-    ] : []).join("\n") : "";
-    return {
-      text,
-      model
-    };
+  selectAgentsForTasks(tasks) {
+    const roles = new Set(tasks.map((task) => task.agentRole));
+    return Array.from(roles).map((role) => AGENT_CATALOG[role]).sort((left, right) => left.role.localeCompare(right.role));
   }
-};
-var AnthropicMessagesProvider = class {
-  definition;
-  constructor(definition) {
-    this.definition = ProviderDefinitionSchema.parse(definition);
+  toolsForAgent(role) {
+    return this.toolRegistry.byRole(role);
   }
-  async healthCheck() {
-    const apiKey = resolveApiKey(this.definition);
-    if (!apiKey) {
-      return {
-        ok: false,
-        message: `Missing ${this.definition.apiKeyEnv ?? "ANTHROPIC_API_KEY"}`
-      };
-    }
-    return {
-      ok: true,
-      message: `${this.definition.baseUrl ?? "https://api.anthropic.com/v1/messages"} (${this.definition.defaultModel ?? "model not set"})`
-    };
+  canAutoExecuteTask(task) {
+    return task.agentRole !== "session-orchestrator" && task.agentRole !== "execution-manager";
   }
-  async listModels(input) {
-    const apiKey = resolveApiKey(this.definition);
-    if (!apiKey) {
-      throw new Error(`Missing ${this.definition.apiKeyEnv ?? "ANTHROPIC_API_KEY"} for provider "${this.definition.id}".`);
+  async executeTask(sessionId, task, request, plan, options = {}) {
+    if (task.agentRole === "repo-analyst") {
+      return this.executeRepoAnalysisTask(sessionId, task, request);
     }
-    const endpoint = this.definition.baseUrl ?? "https://api.anthropic.com/v1/messages";
-    const modelsEndpoint = endpoint.endsWith("/messages") ? `${endpoint.slice(0, -"/messages".length)}/models` : joinUrl(endpoint, "/models");
-    const payload = await requestJson(modelsEndpoint, {
-      method: "GET",
-      headers: {
-        "anthropic-version": "2023-06-01",
-        "x-api-key": apiKey,
-        ...this.definition.headers
-      }
-    });
-    return mapAnthropicModels(this.definition.id, payload, input);
-  }
-  async generateText(input) {
-    const apiKey = resolveApiKey(this.definition);
-    if (!apiKey) {
-      throw new Error(`Missing ${this.definition.apiKeyEnv ?? "ANTHROPIC_API_KEY"} for provider "${this.definition.id}".`);
+    if (task.agentRole === "planner") {
+      return this.executePlannerTask(sessionId, task, request, plan);
     }
-    const endpoint = this.definition.baseUrl ?? "https://api.anthropic.com/v1/messages";
-    const model = requireModel(this.definition, input);
-    const messages = toChatMessages(input);
-    const systemMessage = messages.find((message) => message.role === "system")?.content;
-    const conversation = messages.filter((message) => message.role !== "system").map((message) => ({
-      role: message.role === "assistant" ? "assistant" : "user",
-      content: message.content
-    }));
-    const response = await requestJson(endpoint, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        "x-api-key": apiKey,
-        "anthropic-version": "2023-06-01",
-        ...this.definition.headers
-      },
-      body: JSON.stringify({
-        model,
-        messages: conversation,
-        ...systemMessage ? {
-          system: systemMessage
-        } : {},
-        max_tokens: input.maxTokens ?? 2048,
-        ...typeof input.temperature === "number" ? {
-          temperature: input.temperature
-        } : {}
-      })
-    });
-    const content = Array.isArray(response.content) ? response.content : [];
-    const text = content.flatMap((item) => typeof item === "object" && item !== null && "text" in item ? [
-      String(item.text)
-    ] : []).join("\n");
-    return {
-      text,
-      model
-    };
-  }
-};
-var OpenAICompatibleProvider = class {
-  definition;
-  constructor(definition) {
-    this.definition = ProviderDefinitionSchema.parse(definition);
+    return this.executeAutonomousSpecialistTask(sessionId, task, request, options);
   }
-  async healthCheck() {
-    if (!this.definition.baseUrl) {
+  async executeAutonomousSpecialistTask(sessionId, task, request, options) {
+    const config = await loadConfig(request.cwd);
+    if (!config) {
       return {
-        ok: false,
-        message: "Missing baseUrl"
+        status: "blocked",
+        summary: `Task ${task.id} cannot run because no .kimbho/config.json was found in ${request.cwd}.`,
+        toolResults: [],
+        artifacts: []
       };
     }
-    const apiKey = resolveApiKey(this.definition);
+    const executor = new AutonomousTaskExecutor(config, this.toolRegistry, this.toolRuntime);
+    return executor.execute(sessionId, task, request, {
+      ...typeof options.maxAgentSteps === "number" ? {
+        maxSteps: options.maxAgentSteps
+      } : {},
+      ...typeof options.maxRepairAttempts === "number" ? {
+        maxRepairAttempts: options.maxRepairAttempts
+      } : {}
+    });
+  }
+  async executeRepoAnalysisTask(sessionId, task, request) {
+    const context = { cwd: request.cwd };
+    const toolResults = await Promise.all([
+      this.safeRunTool("git.status", {}, context),
+      this.safeRunTool("file.read", { path: "package.json" }, context),
+      this.safeRunTool("file.read", { path: "README.md" }, context)
+    ]);
+    const successfulResults = toolResults.filter((result) => result.success);
+    const scripts = extractPackageScripts(successfulResults);
+    const artifactPath = await this.writeLogArtifact(sessionId, "repo-analysis", request.cwd, [
+      `# Repo Analysis`,
+      ``,
+      `Goal: ${request.goal}`,
+      `Workspace: ${request.cwd}`,
+      `Task: ${task.id} - ${task.title}`,
+      ``,
+      `## Observations`,
+      `- Successful tool probes: ${successfulResults.length}/${toolResults.length}`,
+      `- Workspace state: ${request.workspaceState}`,
+      `- Detected scripts: ${scripts.length > 0 ? scripts.join(", ") : "none"}`,
+      ``,
+      renderToolResultSection(toolResults)
+    ].join("\n"));
     return {
-      ok: !this.definition.apiKeyEnv || Boolean(apiKey),
-      message: `${this.definition.baseUrl} (${this.definition.defaultModel ?? "model not set"})${this.definition.apiKeyEnv && !apiKey ? `, missing ${this.definition.apiKeyEnv}` : ""}`
+      status: "completed",
+      summary: `Completed ${task.id}: captured repo analysis and saved ${import_node_path6.default.basename(artifactPath)}.`,
+      toolResults,
+      artifacts: [
+        artifactPath
+      ]
     };
   }
-  async listModels(input) {
-    if (!this.definition.baseUrl) {
-      throw new Error(`Provider "${this.definition.id}" requires baseUrl.`);
-    }
-    const apiKey = resolveApiKey(this.definition);
-    const payload = await requestJson(joinUrl(this.definition.baseUrl, "/models"), {
-      method: "GET",
-      headers: buildProviderHeaders(this.definition, apiKey, false)
-    });
-    return mapOpenAIStyleModels(this.definition.id, payload, input);
-  }
-  async generateText(input) {
-    if (!this.definition.baseUrl) {
-      throw new Error(`Provider "${this.definition.id}" requires baseUrl.`);
-    }
-    const apiKey = resolveApiKey(this.definition);
-    const model = requireModel(this.definition, input);
-    const response = await requestJson(`${this.definition.baseUrl}/chat/completions`, {
-      method: "POST",
-      headers: buildProviderHeaders(this.definition, apiKey),
-      body: JSON.stringify({
-        model,
-        messages: toChatMessages(input),
-        ...typeof input.temperature === "number" ? {
-          temperature: input.temperature
-        } : {},
-        ...typeof input.maxTokens === "number" ? {
-          max_tokens: input.maxTokens
-        } : {}
-      })
-    });
-    const choices = Array.isArray(response.choices) ? response.choices : [];
-    const firstChoice = choices.length > 0 && typeof choices[0] === "object" && choices[0] !== null ? choices[0] : null;
-    const message = firstChoice && typeof firstChoice.message === "object" && firstChoice.message !== null ? firstChoice.message : null;
+  async executePlannerTask(sessionId, task, request, plan) {
+    const artifactPath = await this.writeLogArtifact(sessionId, "architecture-brief", request.cwd, [
+      `# Architecture Brief`,
+      ``,
+      `Goal: ${request.goal}`,
+      `Summary: ${plan.summary}`,
+      `Repo Strategy: ${plan.repoStrategy.mode} - ${plan.repoStrategy.reasoning}`,
+      ``,
+      `## Assumptions`,
+      ...plan.assumptions.map((assumption) => `- ${assumption}`),
+      ``,
+      `## Milestones`,
+      ...plan.milestones.flatMap((milestone) => [
+        `### ${milestone.title}`,
+        milestone.objective,
+        ...milestone.tasks.map((milestoneTask) => `- ${milestoneTask.id}: ${milestoneTask.title} [${milestoneTask.agentRole}]`),
+        ``
+      ]),
+      `## Verification`,
+      ...plan.verificationChecklist.map((item) => `- ${item}`)
+    ].join("\n"));
     return {
-      text: typeof message?.content === "string" ? message.content : "",
-      model
+      status: "completed",
+      summary: `Completed ${task.id}: wrote architecture brief ${import_node_path6.default.basename(artifactPath)}.`,
+      toolResults: [],
+      artifacts: [
+        artifactPath
+      ]
     };
   }
-};
-var OllamaProvider = class {
-  definition;
-  constructor(definition) {
-    this.definition = ProviderDefinitionSchema.parse(definition);
-  }
-  async healthCheck() {
-    const baseUrl = this.definition.baseUrl ?? "http://localhost:11434";
+  async safeRunTool(toolId, input, context) {
     try {
-      await requestJson(`${baseUrl}/api/tags`, { method: "GET" }, 2e3);
-      return {
-        ok: true,
-        message: `${baseUrl} (${this.definition.defaultModel ?? "model not set"})`
-      };
+      return await this.toolRuntime.run(toolId, input, context);
     } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
       return {
-        ok: false,
-        message: error instanceof Error ? error.message : String(error)
+        toolId,
+        success: false,
+        summary: `${toolId} failed: ${message}`,
+        stderr: message,
+        artifacts: []
       };
     }
   }
-  async listModels(input) {
-    const baseUrl = this.definition.baseUrl ?? "http://localhost:11434";
-    const payload = await requestJson(`${baseUrl}/api/tags`, { method: "GET" }, 2e3);
-    return mapOllamaModels(this.definition.id, payload, input);
-  }
-  async generateText(input) {
-    const baseUrl = this.definition.baseUrl ?? "http://localhost:11434";
-    const model = requireModel(this.definition, input);
-    const response = await requestJson(`${baseUrl}/api/generate`, {
-      method: "POST",
-      headers: {
-        "content-type": "application/json",
-        ...this.definition.headers
-      },
-      body: JSON.stringify({
-        model,
-        prompt: input.userPrompt ?? toPromptText(input),
-        ...input.systemPrompt ? {
-          system: input.systemPrompt
-        } : {},
-        stream: false,
-        ...typeof input.temperature === "number" ? {
-          options: {
-            temperature: input.temperature
-          }
-        } : {}
-      })
-    });
-    return {
-      text: typeof response.response === "string" ? response.response : "",
-      model
-    };
-  }
-};
-async function createCustomModuleProvider(definition, cwd) {
-  if (!definition.modulePath) {
-    throw new Error(`Provider "${definition.id}" requires modulePath.`);
-  }
-  const modulePath = import_node_path5.default.isAbsolute(definition.modulePath) ? definition.modulePath : import_node_path5.default.join(cwd, definition.modulePath);
-  await (0, import_promises5.access)(modulePath);
-  const module2 = await import((0, import_node_url.pathToFileURL)(modulePath).href);
-  const createProvider = typeof module2.createProvider === "function" ? module2.createProvider : typeof module2.default === "function" ? module2.default : null;
-  if (!createProvider) {
-    throw new Error(`Custom provider module "${modulePath}" must export createProvider(definition).`);
-  }
-  return createProvider(definition);
-}
-var BUILTIN_FACTORIES = {
-  "openai-responses": {
-    driver: "openai-responses",
-    create: async (definition) => new OpenAIResponsesProvider(definition)
-  },
-  "anthropic-messages": {
-    driver: "anthropic-messages",
-    create: async (definition) => new AnthropicMessagesProvider(definition)
-  },
-  "openai-compatible": {
-    driver: "openai-compatible",
-    create: async (definition) => new OpenAICompatibleProvider(definition)
-  },
-  ollama: {
-    driver: "ollama",
-    create: async (definition) => new OllamaProvider(definition)
-  },
-  "custom-module": {
-    driver: "custom-module",
-    create: (definition, cwd) => createCustomModuleProvider(definition, cwd)
+  async writeLogArtifact(sessionId, label, cwd, content) {
+    await ensureKimbhoDir(cwd);
+    const logsDir = import_node_path6.default.join(resolveKimbhoDir(cwd), "logs");
+    const outputPath = import_node_path6.default.join(logsDir, `${sessionId}-${label}.md`);
+    await (0, import_promises6.writeFile)(outputPath, `${content}
+`, "utf8");
+    return outputPath;
   }
 };
-var BrainProviderRegistry = class {
-  cwd;
-  factories;
-  constructor(cwd = process.cwd(), factories = Object.values(BUILTIN_FACTORIES)) {
-    this.cwd = cwd;
-    this.factories = new Map(factories.map((factory) => [factory.driver, factory]));
-  }
-  listDrivers() {
-    return Array.from(this.factories.keys()).sort();
-  }
-  async createProvider(definition) {
-    const normalized = ProviderDefinitionSchema.parse(definition);
-    const factory = this.factories.get(normalized.driver);
-    if (!factory) {
-      throw new Error(`No provider factory registered for driver "${normalized.driver}".`);
+
+// src/commands/agents.ts
+function createAgentsCommand() {
+  return new Command("agents").description("Show the current agent hierarchy and allowed tools.").option("--active", "Show only agents assigned to the latest session", false).action(async (options) => {
+    const orchestrator = new ExecutionOrchestrator();
+    const session = options.active ? await loadLatestSession(process.cwd()) : null;
+    const profiles = session ? listAgentProfiles().filter((agent) => session.assignedAgents.includes(agent.role)) : listAgentProfiles();
+    if (session) {
+      console.log(`Session: ${session.id}`);
+      console.log(`Ready tasks: ${session.readyTaskIds.join(", ") || "none"}`);
+      console.log(`Blocked tasks: ${session.blockedTaskIds.join(", ") || "none"}`);
     }
-    return factory.create(normalized, this.cwd);
-  }
-  async healthCheck(definition) {
-    const provider = await this.createProvider(definition);
-    return provider.healthCheck();
-  }
-  async listModels(definition, input) {
-    const provider = await this.createProvider(definition);
-    if (provider.listModels) {
-      return provider.listModels(input);
+    for (const agent of profiles) {
+      const tools = orchestrator.toolsForAgent(agent.role).map((tool) => tool.id);
+      console.log(`${agent.role}`);
+      console.log(`  brain: ${agent.brainRole}`);
+      console.log(`  purpose: ${agent.purpose}`);
+      console.log(`  tools: ${tools.join(", ")}`);
+      console.log(`  concurrency: ${agent.maxConcurrentTasks}`);
     }
-    return filterModels(definition.models.map((modelId) => ProviderModelSchema.parse({
-      id: modelId,
-      providerId: definition.id
-    })), input);
-  }
-};
-function createDefaultBrainProviderRegistry(cwd = process.cwd()) {
-  return new BrainProviderRegistry(cwd);
+  });
 }
 
-// ../brains/dist/resolver.js
-var BrainResolver = class {
-  config;
-  registry;
-  constructor(config, registry = createDefaultBrainProviderRegistry()) {
-    this.config = config;
-    this.registry = registry;
-  }
-  async resolve(role) {
-    const settings = resolveBrainSettings(this.config, role);
-    const provider = findProviderById(this.config, settings.providerId);
-    if (!provider) {
-      throw new Error(`Brain role "${role}" points to unknown provider "${settings.providerId}".`);
-    }
-    const model = resolveBrainModel(this.config, role);
-    if (!model) {
-      throw new Error(`Brain role "${role}" does not resolve to a model.`);
-    }
-    return {
-      role,
-      settings,
-      provider,
-      model,
-      client: await this.registry.createProvider(provider)
-    };
-  }
-};
+// src/commands/brains.ts
+var import_node_process2 = __toESM(require("node:process"), 1);
 
 // src/ui/renderPlan.ts
 function humanizeRole(role) {
@@ -9860,7 +10805,7 @@ function createModelsCommand() {
     console.log(`Updated ${outputPath}`);
     console.log(`Synced ${models.length} models for ${provider.id}`);
   });
-  command.command("use").description("Select a model for a provider and optionally assign it to a brain role.").argument("<model>", "Model id to select").requiredOption("--provider <provider>", "Provider id to use").option("--role <role>", "Brain role to assign: planner, coder, reviewer, or fast").option("--set-default", "Also set this model as the provider default", false).option("--force", "Skip remote model validation", false).option("--temperature <value>", "Temperature override for the role", parseNumber2).option("--max-tokens <value>", "Max token override for the role", parseInteger).action(async (model, options) => {
+  command.command("use").description("Select a model for a provider and assign it globally unless a specific role is requested.").argument("<model>", "Model id to select").requiredOption("--provider <provider>", "Provider id to use").option("--role <role>", "Brain role to assign: planner, coder, reviewer, or fast").option("--set-default", "Also set this model as the provider default", false).option("--force", "Skip remote model validation", false).option("--temperature <value>", "Temperature override for the role", parseNumber2).option("--max-tokens <value>", "Max token override for the role", parseInteger).action(async (model, options) => {
     let config = await loadConfig(import_node_process5.default.cwd());
     if (!config) {
       requireConfigMessage2();
@@ -9910,12 +10855,16 @@ function createModelsCommand() {
           maxTokens: options.maxTokens
         } : {}
       });
+    } else {
+      config = assignProviderToAllBrains(config, provider.id, model);
     }
     const outputPath = await saveConfig(config, import_node_process5.default.cwd());
     console.log(`Updated ${outputPath}`);
     console.log(`Selected ${provider.id}/${model}`);
     if (options.role) {
       console.log(`Assigned role ${options.role}`);
+    } else {
+      console.log("Assigned all roles");
     }
     if (shouldSetDefault) {
       console.log(`Set provider default model to ${model}`);
@@ -9925,7 +10874,7 @@ function createModelsCommand() {
 }
 
 // src/commands/plan.ts
-var import_promises6 = require("node:fs/promises");
+var import_promises7 = require("node:fs/promises");
 var import_node_process6 = __toESM(require("node:process"), 1);
 
 // ../planner/dist/planner.js
@@ -10230,7 +11179,7 @@ function createPlan(input) {
 
 // src/commands/plan.ts
 async function detectWorkspaceState(cwd) {
-  const entries = await (0, import_promises6.readdir)(cwd);
+  const entries = await (0, import_promises7.readdir)(cwd);
   const meaningfulEntries = entries.filter((entry) => entry !== ".kimbho" && !entry.startsWith("."));
   return meaningfulEntries.length === 0 ? "empty" : "existing";
 }
@@ -10393,7 +11342,7 @@ function parseCount(value) {
   return parsed;
 }
 function createResumeCommand() {
-  return new Command("resume").description("Resume the latest saved Kimbho session snapshot.").option("--json", "Print the latest session as JSON", false).option("--execute", "Continue auto-executing the ready-task frontier", false).option("--max-auto-tasks <count>", "Maximum ready tasks to auto-execute", parseCount, 2).action(async (options) => {
+  return new Command("resume").description("Resume the latest saved Kimbho session snapshot.").option("--json", "Print the latest session as JSON", false).option("--execute", "Continue auto-executing the ready-task frontier", false).option("--max-auto-tasks <count>", "Maximum ready tasks to auto-execute", parseCount, 2).option("--max-agent-steps <count>", "Maximum tool/model steps per autonomous task", parseCount, 8).option("--max-repair-attempts <count>", "Maximum failed verification cycles per autonomous task", parseCount, 2).action(async (options) => {
     const cwd = import_node_process8.default.cwd();
     const session = await loadLatestSession(cwd);
     if (!session) {
@@ -10402,7 +11351,9 @@ function createResumeCommand() {
       return;
     }
     const snapshot = options.execute ? await new ExecutionOrchestrator().continueSession(session, {
-      maxAutoTasks: options.maxAutoTasks
+      maxAutoTasks: options.maxAutoTasks,
+      maxAgentSteps: options.maxAgentSteps,
+      maxRepairAttempts: options.maxRepairAttempts
     }) : session;
     if (options.execute) {
       await saveSession(snapshot, cwd);
@@ -10416,10 +11367,10 @@ function createResumeCommand() {
 }
 
 // src/commands/run.ts
-var import_promises7 = require("node:fs/promises");
+var import_promises8 = require("node:fs/promises");
 var import_node_process9 = __toESM(require("node:process"), 1);
 async function detectWorkspaceState2(cwd) {
-  const entries = await (0, import_promises7.readdir)(cwd);
+  const entries = await (0, import_promises8.readdir)(cwd);
   const meaningfulEntries = entries.filter((entry) => entry !== ".kimbho" && !entry.startsWith("."));
   return meaningfulEntries.length === 0 ? "empty" : "existing";
 }
@@ -10436,7 +11387,7 @@ function createRunCommand() {
     "Explicit execution constraint; can be provided multiple times",
     (value, previous = []) => [...previous, value],
     []
-  ).option("--json", "Print the session snapshot as JSON", false).option("--snapshot-only", "Create the session without auto-executing ready tasks", false).option("--max-auto-tasks <count>", "Maximum ready tasks to auto-execute", parseCount2, 2).action(async (goal, options) => {
+  ).option("--json", "Print the session snapshot as JSON", false).option("--snapshot-only", "Create the session without auto-executing ready tasks", false).option("--max-auto-tasks <count>", "Maximum ready tasks to auto-execute", parseCount2, 2).option("--max-agent-steps <count>", "Maximum tool/model steps per autonomous task", parseCount2, 8).option("--max-repair-attempts <count>", "Maximum failed verification cycles per autonomous task", parseCount2, 2).action(async (goal, options) => {
     const cwd = import_node_process9.default.cwd();
     const orchestrator = new ExecutionOrchestrator();
     let request;
@@ -10471,7 +11422,9 @@ function createRunCommand() {
     const envelope = orchestrator.buildEnvelope(request, plan);
     const initialSnapshot = orchestrator.createSessionSnapshot(envelope);
     const snapshot = options.snapshotOnly ? initialSnapshot : await orchestrator.continueSession(initialSnapshot, {
-      maxAutoTasks: options.maxAutoTasks
+      maxAutoTasks: options.maxAutoTasks,
+      maxAgentSteps: options.maxAgentSteps,
+      maxRepairAttempts: options.maxRepairAttempts
     });
     const sessionPath = await saveSession(snapshot, cwd);
     if (options.json) {
@@ -10559,7 +11512,7 @@ function createProgram(onOpenShell) {
 }
 
 // src/shell.ts
-var import_promises8 = require("node:readline/promises");
+var import_promises9 = require("node:readline/promises");
 var import_node_process10 = __toESM(require("node:process"), 1);
 var AMBER = "\x1B[38;5;214m";
 var BOLD = "\x1B[1m";
@@ -10587,6 +11540,9 @@ var TOP_LEVEL_COMMANDS = /* @__PURE__ */ new Set([
   "select",
   "shell",
   "status",
+  "ask",
+  "chat",
+  "reset-chat",
   "use-model"
 ]);
 var MODEL_SUBCOMMANDS = /* @__PURE__ */ new Set([
@@ -10601,6 +11557,7 @@ var BRAIN_ROLES = [
   "reviewer",
   "fast"
 ];
+var MAX_CHAT_MESSAGES = 12;
 function color(code, value) {
   return `${code}${value}${RESET}`;
 }
@@ -10670,15 +11627,19 @@ function renderHelp() {
     `${color(DIM, "Commands")}`,
     "/status                  Show the active role, provider, and workspace state.",
     "/brain <role>            Change shell focus to planner, coder, reviewer, or fast.",
+    "/ask <prompt>            Send a prompt to the active model.",
+    "/chat <prompt>           Alias for /ask <prompt>.",
+    "/reset-chat              Clear the active model conversation history.",
     "/model                   Show current brain assignments.",
     "/providers               List configured providers.",
     "/providers templates     Show built-in provider templates.",
-    "/providers add <tpl> [id] Add a provider from a built-in template.",
-    "/providers use <id> [role] Use a provider for the active role.",
+    "/providers add <tpl> [id] [--base-url <url>] [--model <id>] [--api-key-env <env>]",
+    "                         Add a provider from a built-in template.",
+    "/providers use <id>      Use a provider for all agent roles.",
     "/providers check         Run provider health checks.",
     "/models [search]         Discover models for the active role's provider.",
     "/select <n>              Select a model from the last numbered /models list.",
-    "/use-model <id>          Assign a model to the active role and provider.",
+    "/use-model <id>          Assign a model to all agent roles.",
     "/plan <goal>             Create a structured implementation plan.",
     "/run <goal>              Start a Kimbho execution session for a goal.",
     "/resume                  Show the latest saved session.",
@@ -10688,7 +11649,7 @@ function renderHelp() {
     "/quit, /exit             Leave the shell.",
     "",
     `${color(DIM, "Tip")}`,
-    "Type a natural-language goal directly and Kimbho will treat it as /run <goal>."
+    "Type natural language directly to chat with the active model. Use /run when you want a plan/session."
   ].join("\n");
 }
 function renderStartupCard(cwd, state) {
@@ -10703,7 +11664,7 @@ function renderStartupCard(cwd, state) {
     renderCardLine("approval", state.approvalMode),
     renderCardLine("sandbox", state.sandboxMode),
     renderCardLine("preset", state.stackPreset),
-    renderCardLine("shortcuts", "/brain  /providers  /models  /select  /use-model  /quit")
+    renderCardLine("shortcuts", "/ask  /run  /brain  /providers  /models  /quit")
   ];
   if (!state.configured) {
     cardLines.push("setup: run /init or /providers add <template> to create .kimbho/config.json");
@@ -10719,7 +11680,7 @@ function printHeader(cwd, state) {
   console.log(color(DIM, "Terminal-native coding agent"));
   console.log(renderStartupCard(cwd, state));
   console.log("");
-  console.log(color(DIM, "Tip: configure providers and models here, then describe the work and Kimbho will route it into /run."));
+  console.log(color(DIM, "Tip: configure providers and models here, then chat directly. Use /run for planning and execution."));
   console.log(renderHelp());
   console.log("");
 }
@@ -10795,6 +11756,63 @@ function normalizeInputTokens(input) {
     head: firstToken.startsWith("/") ? firstToken.slice(1) : firstToken
   };
 }
+function trimConversation(messages) {
+  if (messages.length <= MAX_CHAT_MESSAGES) {
+    return messages;
+  }
+  return messages.slice(messages.length - MAX_CHAT_MESSAGES);
+}
+function clearConversation(runtime, role) {
+  runtime.conversations[role] = [];
+}
+function getConversation(runtime, role) {
+  return runtime.conversations[role] ?? [];
+}
+function clearAllConversations(runtime) {
+  for (const role of BRAIN_ROLES) {
+    runtime.conversations[role] = [];
+  }
+}
+async function handleChatPrompt(cwd, prompt, runtime) {
+  const config = await loadConfig(cwd);
+  if (!config) {
+    throw new Error("No config found. Run /init or /providers add <template> first.");
+  }
+  const registry = createDefaultBrainProviderRegistry(cwd);
+  const resolver = new BrainResolver(config, registry);
+  const brain = await resolver.resolve(runtime.focusRole);
+  const history = getConversation(runtime, runtime.focusRole);
+  const messages = trimConversation([
+    ...history,
+    {
+      role: "user",
+      content: prompt
+    }
+  ]);
+  const result = await brain.client.generateText({
+    model: brain.model,
+    messages,
+    ...brain.settings.promptPreamble ? {
+      systemPrompt: brain.settings.promptPreamble
+    } : {},
+    ...typeof brain.settings.temperature === "number" ? {
+      temperature: brain.settings.temperature
+    } : {},
+    ...typeof brain.settings.maxTokens === "number" ? {
+      maxTokens: brain.settings.maxTokens
+    } : {}
+  });
+  const nextConversation = trimConversation([
+    ...messages,
+    {
+      role: "assistant",
+      content: result.text
+    }
+  ]);
+  runtime.conversations[runtime.focusRole] = nextConversation;
+  console.log(color(DIM, `[${brain.role}] ${brain.provider.id}/${brain.model}`));
+  console.log(result.text);
+}
 function defaultProviderIdForTemplate(templateId) {
   switch (templateId) {
     case "openai":
@@ -10811,6 +11829,52 @@ function defaultProviderIdForTemplate(templateId) {
       return `${templateId}-main`;
   }
 }
+function parseProviderAddOptions(tokens) {
+  const templateId = tokens[2];
+  if (!templateId) {
+    throw new Error("Usage: /providers add <template> [provider-id] [--base-url <url>] [--model <id>] [--api-key-env <env>]");
+  }
+  let index = 3;
+  let providerId;
+  if (tokens[index] && !tokens[index]?.startsWith("-")) {
+    providerId = tokens[index];
+    index += 1;
+  }
+  const options = {
+    templateId,
+    ...providerId ? {
+      providerId
+    } : {}
+  };
+  while (index < tokens.length) {
+    const flag = tokens[index];
+    if (!flag?.startsWith("--")) {
+      throw new Error(`Unexpected token "${flag}".`);
+    }
+    const value = tokens[index + 1];
+    if (!value || value.startsWith("--")) {
+      throw new Error(`Missing value for ${flag}.`);
+    }
+    switch (flag) {
+      case "--label":
+        options.label = value;
+        break;
+      case "--base-url":
+        options.baseUrl = normalizeTemplateBaseUrl(templateId, value) ?? value;
+        break;
+      case "--api-key-env":
+        options.apiKeyEnv = value;
+        break;
+      case "--model":
+        options.model = value;
+        break;
+      default:
+        throw new Error(`Unknown option "${flag}". Supported: --label, --base-url, --api-key-env, --model.`);
+    }
+    index += 2;
+  }
+  return options;
+}
 function buildCachedModels(provider, search, limit = 25) {
   const normalized = search?.trim().toLowerCase();
   const filtered = normalized ? provider.models.filter((modelId) => modelId.toLowerCase().includes(normalized)) : provider.models;
@@ -10857,7 +11921,7 @@ async function fetchModelsForProvider(cwd, config, provider, search, limit = 25)
     throw error;
   }
 }
-async function assignModelToRole(cwd, role, providerId, model) {
+async function assignModelGlobally(cwd, providerId, model) {
   const config = await loadConfig(cwd);
   if (!config) {
     throw new Error("No config found. Run /init or /providers add first.");
@@ -10866,8 +11930,7 @@ async function assignModelToRole(cwd, role, providerId, model) {
   if (!provider) {
     throw new Error(`Unknown provider "${providerId}".`);
   }
-  const currentSettings = resolveBrainSettings(config, role);
-  const nextConfig = assignBrain(
+  const nextConfig = assignProviderToAllBrains(
     upsertProvider(config, {
       ...provider,
       defaultModel: model,
@@ -10876,25 +11939,13 @@ async function assignModelToRole(cwd, role, providerId, model) {
         model
       ]))
     }),
-    role,
-    {
-      providerId,
-      model,
-      ...typeof currentSettings.temperature === "number" ? {
-        temperature: currentSettings.temperature
-      } : {},
-      ...typeof currentSettings.maxTokens === "number" ? {
-        maxTokens: currentSettings.maxTokens
-      } : {},
-      ...currentSettings.promptPreamble ? {
-        promptPreamble: currentSettings.promptPreamble
-      } : {}
-    }
+    providerId,
+    model
   );
   const outputPath = await saveConfig(nextConfig, cwd);
   return outputPath;
 }
-async function useProviderForRole(cwd, role, providerId) {
+async function useProviderGlobally(cwd, providerId) {
   const config = await loadConfig(cwd);
   if (!config) {
     throw new Error("No config found. Run /init or /providers add first.");
@@ -10903,23 +11954,8 @@ async function useProviderForRole(cwd, role, providerId) {
   if (!provider) {
     throw new Error(`Unknown provider "${providerId}".`);
   }
-  const currentSettings = resolveBrainSettings(config, role);
   const resolvedModel = provider.defaultModel ?? provider.models[0] ?? null;
-  const nextConfig = assignBrain(config, role, {
-    providerId: provider.id,
-    ...resolvedModel ? {
-      model: resolvedModel
-    } : {},
-    ...typeof currentSettings.temperature === "number" ? {
-      temperature: currentSettings.temperature
-    } : {},
-    ...typeof currentSettings.maxTokens === "number" ? {
-      maxTokens: currentSettings.maxTokens
-    } : {},
-    ...currentSettings.promptPreamble ? {
-      promptPreamble: currentSettings.promptPreamble
-    } : {}
-  });
+  const nextConfig = assignProviderToAllBrains(config, provider.id, resolvedModel);
   const outputPath = await saveConfig(nextConfig, cwd);
   return {
     outputPath,
@@ -10950,6 +11986,7 @@ async function printProviderList(cwd, focusRole) {
     console.log(`  label: ${provider.label ?? "-"}`);
     console.log(`  driver: ${provider.driver}`);
     console.log(`  model: ${provider.defaultModel ?? "-"}`);
+    console.log(`  baseUrl: ${provider.baseUrl ?? "-"}`);
     console.log(`  auth: ${envState}`);
     console.log(`  cachedModels: ${provider.models.length}`);
   }
@@ -10964,9 +12001,21 @@ function printProviderTemplates() {
     console.log(`  notes: ${template.notes}`);
   }
 }
-async function addProviderFromTemplate(cwd, templateId, providerId) {
-  const provider = buildProviderFromTemplate(templateId, {
-    providerId: providerId ?? defaultProviderIdForTemplate(templateId)
+async function addProviderFromTemplate(cwd, options) {
+  const provider = buildProviderFromTemplate(options.templateId, {
+    providerId: options.providerId ?? defaultProviderIdForTemplate(options.templateId),
+    ...options.label ? {
+      label: options.label
+    } : {},
+    ...options.baseUrl ? {
+      baseUrl: options.baseUrl
+    } : {},
+    ...options.apiKeyEnv ? {
+      apiKeyEnv: options.apiKeyEnv
+    } : {},
+    ...options.model ? {
+      model: options.model
+    } : {}
   });
   const config = await loadConfig(cwd);
   if (!config) {
@@ -11025,30 +12074,27 @@ async function handleProvidersCommand(cwd, tokens, runtime) {
     return;
   }
   if (subcommand === "add") {
-    const templateId = tokens[2];
-    const providerId = tokens[3];
-    if (!templateId) {
-      throw new Error("Usage: /providers add <template> [provider-id]");
-    }
-    const outputPath = await addProviderFromTemplate(cwd, templateId, providerId);
-    const resolvedProviderId = providerId ?? defaultProviderIdForTemplate(templateId);
+    const options = parseProviderAddOptions(tokens);
+    const outputPath = await addProviderFromTemplate(cwd, options);
+    const resolvedProviderId = options.providerId ?? defaultProviderIdForTemplate(options.templateId);
     console.log(`Updated ${outputPath}`);
-    console.log(`Added provider ${resolvedProviderId} from template ${templateId}`);
+    console.log(`Added provider ${resolvedProviderId} from template ${options.templateId}`);
+    if (options.baseUrl) {
+      console.log(`Base URL ${options.baseUrl}`);
+    }
     console.log(`Next: /providers use ${resolvedProviderId}`);
     return;
   }
   if (subcommand === "use") {
     const providerId = tokens[2];
-    const role = tokens[3];
     if (!providerId) {
-      throw new Error("Usage: /providers use <provider-id> [role]");
+      throw new Error("Usage: /providers use <provider-id>");
     }
-    const targetRole = role && isBrainRole(role) ? role : runtime.focusRole;
-    const result = await useProviderForRole(cwd, targetRole, providerId);
-    runtime.focusRole = targetRole;
+    const result = await useProviderGlobally(cwd, providerId);
+    clearAllConversations(runtime);
     runtime.lastModels = null;
     console.log(`Updated ${result.outputPath}`);
-    console.log(`Focus role ${targetRole} now uses provider ${providerId}${result.model ? ` (${result.model})` : ""}`);
+    console.log(`All roles now use provider ${providerId}${result.model ? ` (${result.model})` : ""}`);
     return;
   }
   throw new Error("Usage: /providers [list|templates|add|use|check]");
@@ -11089,10 +12135,11 @@ async function handleModelsCommand(cwd, tokens, runtime) {
     if (!modelId) {
       throw new Error("Usage: /models use <model-id>");
     }
-    const outputPath = await assignModelToRole(cwd, runtime.focusRole, provider.id, modelId);
+    const outputPath = await assignModelGlobally(cwd, provider.id, modelId);
+    clearAllConversations(runtime);
     console.log(`Updated ${outputPath}`);
     console.log(`Selected ${provider.id}/${modelId}`);
-    console.log(`Assigned role ${runtime.focusRole}`);
+    console.log("Assigned all roles");
     return;
   }
   const search = !subcommand || MODEL_SUBCOMMANDS.has(subcommand) ? void 0 : tokens.slice(1).join(" ");
@@ -11118,7 +12165,7 @@ async function handleModelsCommand(cwd, tokens, runtime) {
     console.log(`  ${index + 1}. ${renderModelLine2(model)}`);
   }
   console.log(``);
-  console.log(`Use /select <number> or /use-model <model-id> to assign one to ${runtime.focusRole}.`);
+  console.log("Use /select <number> or /use-model <model-id> to assign one to all roles.");
 }
 async function handleModelSelection(cwd, modelId, runtime) {
   const config = await loadConfig(cwd);
@@ -11130,10 +12177,11 @@ async function handleModelSelection(cwd, modelId, runtime) {
   if (!provider) {
     throw new Error(`Active role "${runtime.focusRole}" points to unknown provider "${providerId}".`);
   }
-  const outputPath = await assignModelToRole(cwd, runtime.focusRole, provider.id, modelId);
+  const outputPath = await assignModelGlobally(cwd, provider.id, modelId);
+  clearAllConversations(runtime);
   console.log(`Updated ${outputPath}`);
   console.log(`Selected ${provider.id}/${modelId}`);
-  console.log(`Assigned role ${runtime.focusRole}`);
+  console.log("Assigned all roles");
 }
 async function handleSelectCommand(cwd, tokens, runtime) {
   const rawIndex = tokens[1];
@@ -11176,10 +12224,22 @@ function toExternalCommandTokens(input, state) {
       `scaffold ${goal}`.trim()
     ];
   }
-  if (!firstToken.startsWith("/") && !TOP_LEVEL_COMMANDS.has(head) && !head.startsWith("-")) {
-    return [
+  if (head === "run") {
+    const goal = normalizedInput.replace(/^\/?run\b\s*/, "");
+    return goal ? [
       "run",
-      normalizedInput
+      goal
+    ] : [
+      "run"
+    ];
+  }
+  if (head === "plan") {
+    const goal = normalizedInput.replace(/^\/?plan\b\s*/, "");
+    return goal ? [
+      "plan",
+      goal
+    ] : [
+      "plan"
     ];
   }
   tokens[0] = head;
@@ -11210,9 +12270,14 @@ async function handleShellCommand(cwd, input, state, runtime, execute) {
     return;
   }
   const { tokens, head } = normalizeInputTokens(trimmed);
+  const firstToken = tokens[0];
   if (!head) {
     return;
   }
+  if (!firstToken?.startsWith("/") && !TOP_LEVEL_COMMANDS.has(head) && !head.startsWith("-")) {
+    await handleChatPrompt(cwd, trimmed, runtime);
+    return;
+  }
   if (head === "provider" || head === "providers") {
     const subcommand = tokens[1];
     const canHandleLocally = !subcommand || subcommand === "list" || subcommand === "templates" || subcommand === "check" || subcommand === "use" || subcommand === "add" && Boolean(tokens[2]) && !tokens[2]?.startsWith("-");
@@ -11240,6 +12305,19 @@ async function handleShellCommand(cwd, input, state, runtime, execute) {
     await printBrainAssignments(cwd);
     return;
   }
+  if (head === "ask" || head === "chat") {
+    const prompt = tokens.slice(1).join(" ").trim();
+    if (!prompt) {
+      throw new Error(`Usage: /${head} <prompt>`);
+    }
+    await handleChatPrompt(cwd, prompt, runtime);
+    return;
+  }
+  if (head === "reset-chat") {
+    clearConversation(runtime, runtime.focusRole);
+    console.log(`Cleared ${runtime.focusRole} conversation history.`);
+    return;
+  }
   if (head === "models") {
     await handleModelsCommand(cwd, [
       "models",
@@ -11269,14 +12347,20 @@ async function handleShellCommand(cwd, input, state, runtime, execute) {
   await execute(externalTokens);
 }
 async function runInteractiveShell(options) {
-  const readline = (0, import_promises8.createInterface)({
+  const readline = (0, import_promises9.createInterface)({
     input: import_node_process10.default.stdin,
     output: import_node_process10.default.stdout,
     terminal: Boolean(import_node_process10.default.stdin.isTTY && import_node_process10.default.stdout.isTTY)
   });
   const runtime = {
     focusRole: "coder",
-    lastModels: null
+    lastModels: null,
+    conversations: {
+      planner: [],
+      coder: [],
+      reviewer: [],
+      fast: []
+    }
   };
   let closed = false;
   readline.on("SIGINT", () => {