@kimbho/kimbho-cli 0.1.1 → 0.1.3

package/dist/index.cjs

@@ -1147,9 +1147,9 @@ var require_command = __commonJS({
   "../../node_modules/commander/lib/command.js"(exports2) {
     var EventEmitter = require("node:events").EventEmitter;
     var childProcess = require("node:child_process");
-    var path4 = require("node:path");
+    var path6 = require("node:path");
     var fs = require("node:fs");
-    var process11 = require("node:process");
+    var process12 = require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
     var { CommanderError: CommanderError2 } = require_error();
     var { Help: Help2, stripColor } = require_help();
@@ -1196,13 +1196,13 @@ var require_command = __commonJS({
         this._showSuggestionAfterError = true;
         this._savedState = null;
         this._outputConfiguration = {
-          writeOut: (str) => process11.stdout.write(str),
-          writeErr: (str) => process11.stderr.write(str),
+          writeOut: (str) => process12.stdout.write(str),
+          writeErr: (str) => process12.stderr.write(str),
           outputError: (str, write) => write(str),
-          getOutHelpWidth: () => process11.stdout.isTTY ? process11.stdout.columns : void 0,
-          getErrHelpWidth: () => process11.stderr.isTTY ? process11.stderr.columns : void 0,
-          getOutHasColors: () => useColor() ?? (process11.stdout.isTTY && process11.stdout.hasColors?.()),
-          getErrHasColors: () => useColor() ?? (process11.stderr.isTTY && process11.stderr.hasColors?.()),
+          getOutHelpWidth: () => process12.stdout.isTTY ? process12.stdout.columns : void 0,
+          getErrHelpWidth: () => process12.stderr.isTTY ? process12.stderr.columns : void 0,
+          getOutHasColors: () => useColor() ?? (process12.stdout.isTTY && process12.stdout.hasColors?.()),
+          getErrHasColors: () => useColor() ?? (process12.stderr.isTTY && process12.stderr.hasColors?.()),
           stripColor: (str) => stripColor(str)
         };
         this._hidden = false;
@@ -1585,7 +1585,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         if (this._exitCallback) {
           this._exitCallback(new CommanderError2(exitCode, code, message));
         }
-        process11.exit(exitCode);
+        process12.exit(exitCode);
       }
       /**
        * Register callback `fn` for the command.
@@ -1983,16 +1983,16 @@ Expecting one of '${allowedValues.join("', '")}'`);
         }
         parseOptions = parseOptions || {};
         if (argv === void 0 && parseOptions.from === void 0) {
-          if (process11.versions?.electron) {
+          if (process12.versions?.electron) {
             parseOptions.from = "electron";
           }
-          const execArgv = process11.execArgv ?? [];
+          const execArgv = process12.execArgv ?? [];
           if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
             parseOptions.from = "eval";
           }
         }
         if (argv === void 0) {
-          argv = process11.argv;
+          argv = process12.argv;
         }
         this.rawArgs = argv.slice();
         let userArgs;
@@ -2003,7 +2003,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             userArgs = argv.slice(2);
             break;
           case "electron":
-            if (process11.defaultApp) {
+            if (process12.defaultApp) {
               this._scriptPath = argv[1];
               userArgs = argv.slice(2);
             } else {
@@ -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 = path4.resolve(baseDir, baseName);
+          const localBin = path6.resolve(baseDir, baseName);
           if (fs.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path4.extname(baseName))) return void 0;
+          if (sourceExt.includes(path6.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 = path4.resolve(
-            path4.dirname(resolvedScriptPath),
+          executableDir = path6.resolve(
+            path6.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path4.basename(
+            const legacyName = path6.basename(
               this._scriptPath,
-              path4.extname(this._scriptPath)
+              path6.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2188,13 +2188,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path4.extname(executableFile));
+        launchWithNode = sourceExt.includes(path6.extname(executableFile));
         let proc;
-        if (process11.platform !== "win32") {
+        if (process12.platform !== "win32") {
           if (launchWithNode) {
             args.unshift(executableFile);
-            args = incrementNodeInspectorPort(process11.execArgv).concat(args);
-            proc = childProcess.spawn(process11.argv[0], args, { stdio: "inherit" });
+            args = incrementNodeInspectorPort(process12.execArgv).concat(args);
+            proc = childProcess.spawn(process12.argv[0], args, { stdio: "inherit" });
           } else {
             proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
           }
@@ -2205,13 +2205,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
             subcommand._name
           );
           args.unshift(executableFile);
-          args = incrementNodeInspectorPort(process11.execArgv).concat(args);
-          proc = childProcess.spawn(process11.execPath, args, { stdio: "inherit" });
+          args = incrementNodeInspectorPort(process12.execArgv).concat(args);
+          proc = childProcess.spawn(process12.execPath, args, { stdio: "inherit" });
         }
         if (!proc.killed) {
           const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
           signals.forEach((signal) => {
-            process11.on(signal, () => {
+            process12.on(signal, () => {
               if (proc.killed === false && proc.exitCode === null) {
                 proc.kill(signal);
               }
@@ -2222,7 +2222,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         proc.on("close", (code) => {
           code = code ?? 1;
           if (!exitCallback) {
-            process11.exit(code);
+            process12.exit(code);
           } else {
             exitCallback(
               new CommanderError2(
@@ -2244,7 +2244,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             throw new Error(`'${executableFile}' not executable`);
           }
           if (!exitCallback) {
-            process11.exit(1);
+            process12.exit(1);
           } else {
             const wrappedError = new CommanderError2(
               1,
@@ -2739,13 +2739,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
        */
       _parseOptionsEnv() {
         this.options.forEach((option) => {
-          if (option.envVar && option.envVar in process11.env) {
+          if (option.envVar && option.envVar in process12.env) {
             const optionKey = option.attributeName();
             if (this.getOptionValue(optionKey) === void 0 || ["default", "config", "env"].includes(
               this.getOptionValueSource(optionKey)
             )) {
               if (option.required || option.optional) {
-                this.emit(`optionEnv:${option.name()}`, process11.env[option.envVar]);
+                this.emit(`optionEnv:${option.name()}`, process12.env[option.envVar]);
               } else {
                 this.emit(`optionEnv:${option.name()}`);
               }
@@ -3035,7 +3035,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path4.basename(filename, path4.extname(filename));
+        this._name = path6.basename(filename, path6.extname(filename));
         return this;
       }
       /**
@@ -3049,9 +3049,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path5) {
-        if (path5 === void 0) return this._executableDir;
-        this._executableDir = path5;
+      executableDir(path7) {
+        if (path7 === void 0) return this._executableDir;
+        this._executableDir = path7;
         return this;
       }
       /**
@@ -3200,7 +3200,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        */
       help(contextOptions) {
         this.outputHelp(contextOptions);
-        let exitCode = Number(process11.exitCode ?? 0);
+        let exitCode = Number(process12.exitCode ?? 0);
         if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
           exitCode = 1;
         }
@@ -3290,9 +3290,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
       });
     }
     function useColor() {
-      if (process11.env.NO_COLOR || process11.env.FORCE_COLOR === "0" || process11.env.FORCE_COLOR === "false")
+      if (process12.env.NO_COLOR || process12.env.FORCE_COLOR === "0" || process12.env.FORCE_COLOR === "false")
         return false;
-      if (process11.env.FORCE_COLOR || process11.env.CLICOLOR_FORCE !== void 0)
+      if (process12.env.FORCE_COLOR || process12.env.CLICOLOR_FORCE !== void 0)
         return true;
       return void 0;
     }
@@ -3323,6 +3323,9 @@ var require_commander = __commonJS({
   }
 });
 
+// src/index.ts
+var import_node_child_process3 = require("node:child_process");
+
 // ../../node_modules/commander/esm.mjs
 var import_index = __toESM(require_commander(), 1);
 var {
@@ -3343,7 +3346,7 @@ var {
 // package.json
 var package_default = {
   name: "@kimbho/kimbho-cli",
-  version: "0.1.1",
+  version: "0.1.3",
   description: "Kimbho CLI is a terminal-native coding agent for planning, execution, and verification.",
   type: "module",
   engines: {
@@ -3559,6 +3562,10 @@ function listAgentProfiles() {
   return Object.values(AGENT_CATALOG).sort((left, right) => left.role.localeCompare(right.role));
 }
 
+// ../agent-runtime/dist/orchestrator.js
+var import_promises4 = require("node:fs/promises");
+var import_node_path4 = __toESM(require("node:path"), 1);
+
 // ../../node_modules/zod/v3/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -4037,8 +4044,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path4, errorMaps, issueData } = params;
-  const fullPath = [...path4, ...issueData.path || []];
+  const { data, path: path6, errorMaps, issueData } = params;
+  const fullPath = [...path6, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -4154,11 +4161,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path4, key) {
+  constructor(parent, value, path6, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path4;
+    this._path = path6;
     this._key = key;
   }
   get path() {
@@ -7808,6 +7815,16 @@ var KimbhoConfigSchema = external_exports.object({
   }
 });
 
+// ../core/dist/contracts/execution.js
+var ToolResultSchema = external_exports.object({
+  toolId: external_exports.string().min(1),
+  success: external_exports.boolean(),
+  summary: external_exports.string().min(1),
+  stdout: external_exports.string().optional(),
+  stderr: external_exports.string().optional(),
+  artifacts: external_exports.array(external_exports.string()).default([])
+});
+
 // ../core/dist/contracts/session.js
 var SessionStatusSchema = external_exports.enum([
   "planned",
@@ -7816,6 +7833,22 @@ var SessionStatusSchema = external_exports.enum([
   "blocked",
   "completed"
 ]);
+var SessionEventTypeSchema = external_exports.enum([
+  "task-started",
+  "task-completed",
+  "task-blocked",
+  "note"
+]);
+var SessionEventSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  timestamp: external_exports.string().datetime(),
+  type: SessionEventTypeSchema,
+  taskId: external_exports.string().min(1).optional(),
+  agentRole: AgentRoleSchema.optional(),
+  message: external_exports.string().min(1),
+  toolResults: external_exports.array(ToolResultSchema).default([]),
+  artifacts: external_exports.array(external_exports.string()).default([])
+});
 var SessionSnapshotSchema = external_exports.object({
   id: external_exports.string().min(1),
   goal: external_exports.string().min(1),
@@ -7827,8 +7860,10 @@ var SessionSnapshotSchema = external_exports.object({
   plan: KimbhoPlanSchema,
   readyTaskIds: external_exports.array(external_exports.string()).default([]),
   blockedTaskIds: external_exports.array(external_exports.string()).default([]),
+  completedTaskIds: external_exports.array(external_exports.string()).default([]),
   assignedAgents: external_exports.array(AgentRoleSchema).default([]),
-  notes: external_exports.array(external_exports.string()).default([])
+  notes: external_exports.array(external_exports.string()).default([]),
+  events: external_exports.array(SessionEventSchema).default([])
 });
 
 // ../core/dist/config/config.js
@@ -8116,14 +8151,6 @@ var ToolDescriptorSchema = external_exports.object({
   producesArtifacts: external_exports.boolean().default(false),
   allowedRoles: external_exports.array(AgentRoleSchema).default([])
 });
-var ToolResultSchema = external_exports.object({
-  toolId: external_exports.string().min(1),
-  success: external_exports.boolean(),
-  summary: external_exports.string().min(1),
-  stdout: external_exports.string().optional(),
-  stderr: external_exports.string().optional(),
-  artifacts: external_exports.array(external_exports.string()).default([])
-});
 
 // ../tools/dist/registry.js
 var BUILTIN_TOOLS = [
@@ -8233,26 +8260,296 @@ function createDefaultToolRegistry() {
   return new ToolRegistry(BUILTIN_TOOLS);
 }
 
+// ../tools/dist/runtime.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;
+  }
+  const omitted = value.length - DEFAULT_CAPTURE_LIMIT;
+  return `${value.slice(0, DEFAULT_CAPTURE_LIMIT)}
+... [truncated ${omitted} chars]`;
+}
+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.`);
+  }
+  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_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
+    ]
+  });
+}
+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 runShellCommand("shell.exec", command, context.cwd, timeoutMs);
+}
+async function executeGitStatus(_input, context, timeoutMs) {
+  return runShellCommand("git.status", "git status --short --branch", context.cwd, timeoutMs);
+}
+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_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: []
+    });
+  } finally {
+    await (0, import_promises3.rm)(tempDir, { recursive: true, force: true });
+  }
+}
+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
+      ]
+    ]);
+  }
+  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));
+}
+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 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("```");
+    }
+    if (result.stderr) {
+      lines.push("");
+      lines.push("```text");
+      lines.push(result.stderr);
+      lines.push("```");
+    }
+    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 [];
+  }
+  try {
+    const parsed = JSON.parse(packageResult.stdout);
+    return Object.keys(parsed.scripts ?? {}).sort();
+  } catch {
+    return [];
+  }
+}
 var ExecutionOrchestrator = class {
   toolRegistry;
-  constructor(toolRegistry = createDefaultToolRegistry()) {
+  toolRuntime;
+  constructor(toolRegistry = createDefaultToolRegistry(), toolRuntime = new ToolRuntime(toolRegistry)) {
     this.toolRegistry = toolRegistry;
+    this.toolRuntime = toolRuntime;
   }
-  buildEnvelope(request, plan) {
+  buildEnvelope(request, plan, sessionId = createSessionId()) {
     const tasks = flattenPlanTasks(plan);
-    const completedTaskIds = new Set(tasks.filter((task) => task.status === "completed").map((task) => task.id));
+    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: createSessionId(),
+      sessionId,
       request,
       plan,
       readyTasks,
@@ -8260,9 +8557,9 @@ var ExecutionOrchestrator = class {
       assignedAgents
     };
   }
-  createSessionSnapshot(envelope) {
+  createSessionSnapshot(envelope, overrides = {}) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    const status = envelope.readyTasks.length > 0 ? "ready" : "blocked";
+    const status = deriveStatus(envelope.plan, envelope.readyTasks, envelope.blockedTasks);
     return SessionSnapshotSchema.parse({
       id: envelope.sessionId,
       goal: envelope.request.goal,
@@ -8274,11 +8571,75 @@ var ExecutionOrchestrator = class {
       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.",
-        "Execution tooling is not wired yet; this snapshot captures the ready-task frontier."
-      ]
+        "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);
+      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
+      });
+      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"}.`);
+    }
+    return this.createSessionSnapshot(postLimitEnvelope, {
+      startedAt: session.startedAt,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      notes,
+      events
     });
   }
   selectAgentsForTasks(tasks) {
@@ -8288,6 +8649,107 @@ var ExecutionOrchestrator = class {
   toolsForAgent(role) {
     return this.toolRegistry.byRole(role);
   }
+  canAutoExecuteTask(task) {
+    return task.agentRole === "repo-analyst" || task.agentRole === "planner";
+  }
+  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);
+    }
+    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
+      ]
+    };
+  }
+  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
+      ]
+    };
+  }
+  async safeRunTool(toolId, input, context) {
+    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: []
+      };
+    }
+  }
+  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;
+  }
 };
 
 // src/commands/agents.ts
@@ -8313,7 +8775,7 @@ function createAgentsCommand() {
 }
 
 // src/commands/brains.ts
-var import_node_process = __toESM(require("node:process"), 1);
+var import_node_process2 = __toESM(require("node:process"), 1);
 
 // ../brains/dist/templates.js
 var BUILTIN_PROVIDER_TEMPLATES = [
@@ -8389,8 +8851,8 @@ function buildProviderFromTemplate(templateId, options = {}) {
 }
 
 // ../brains/dist/registry.js
-var import_promises3 = require("node:fs/promises");
-var import_node_path3 = __toESM(require("node:path"), 1);
+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) {
@@ -8446,7 +8908,7 @@ function buildProviderHeaders(definition, apiKey, includeJsonContentType = true)
 }
 function filterModels(models, input = {}) {
   const normalized = input.search?.trim().toLowerCase();
-  const filtered = normalized ? models.filter((model) => [model.id, model.name, model.description].filter((value) => Boolean(value)).some((value) => value.toLowerCase().includes(normalized))) : models;
+  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 mapOpenAIStyleModels(providerId, payload, input) {
@@ -8828,8 +9290,8 @@ 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 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) {
@@ -8978,6 +9440,40 @@ function renderPlan(plan) {
 function renderJson(value) {
   return JSON.stringify(value, null, 2);
 }
+function renderSession(session) {
+  const taskCounts = countTasksByStatus(session.plan);
+  const lines = [
+    `Session: ${session.id}`,
+    `Goal: ${session.goal}`,
+    `Status: ${session.status}`,
+    `Tasks: ${flattenPlanTasks(session.plan).length} total | completed ${taskCounts.completed} | pending ${taskCounts.pending} | blocked ${taskCounts.blocked}`,
+    `Assigned agents: ${session.assignedAgents.join(", ") || "none"}`,
+    `Ready tasks: ${session.readyTaskIds.join(", ") || "none"}`,
+    `Blocked tasks: ${session.blockedTaskIds.join(", ") || "none"}`
+  ];
+  if (session.notes.length > 0) {
+    lines.push("");
+    lines.push("Notes:");
+    for (const note of session.notes.slice(-5)) {
+      lines.push(`- ${note}`);
+    }
+  }
+  if (session.events.length > 0) {
+    lines.push("");
+    lines.push("Recent Events:");
+    for (const event of session.events.slice(-5)) {
+      const target = event.taskId ? `${event.taskId}` : "session";
+      lines.push(`- ${event.type} | ${target} | ${event.message}`);
+      for (const artifact of event.artifacts) {
+        lines.push(`  artifact: ${artifact}`);
+      }
+      for (const toolResult of event.toolResults) {
+        lines.push(`  tool: ${toolResult.toolId} | ${toolResult.success ? "ok" : "fail"} | ${toolResult.summary}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
 
 // src/commands/brains.ts
 function parseNumber(value) {
@@ -8993,7 +9489,7 @@ function requireConfigMessage() {
 function createBrainsCommand() {
   const command = new Command("brains").description("Inspect and assign the LLM brains used by Kimbho roles.");
   command.command("list").description("List brain-role assignments.").option("--json", "Print roles as JSON", false).action(async (options) => {
-    const config = await loadConfig(import_node_process.default.cwd());
+    const config = await loadConfig(import_node_process2.default.cwd());
     if (!config) {
       requireConfigMessage();
     }
@@ -9023,7 +9519,7 @@ function createBrainsCommand() {
     }
   });
   command.command("assign").description("Assign a provider/model pair to a brain role.").requiredOption("--role <role>", "Brain role: planner, coder, reviewer, or fast").requiredOption("--provider <provider>", "Provider id to assign").option("--model <model>", "Model override for this role").option("--temperature <value>", "Temperature override", parseNumber).option("--max-tokens <value>", "Max token override", parseNumber).option("--prompt-preamble <text>", "Additional prompt preamble for this role").action(async (options) => {
-    const config = await loadConfig(import_node_process.default.cwd());
+    const config = await loadConfig(import_node_process2.default.cwd());
     if (!config) {
       requireConfigMessage();
     }
@@ -9047,12 +9543,12 @@ function createBrainsCommand() {
         promptPreamble: options.promptPreamble
       } : {}
     });
-    const outputPath = await saveConfig(nextConfig, import_node_process.default.cwd());
+    const outputPath = await saveConfig(nextConfig, import_node_process2.default.cwd());
     console.log(`Updated ${outputPath}`);
     console.log(`Brain ${role} -> ${provider.id}/${options.model ?? provider.defaultModel ?? "model not set"}`);
   });
   command.command("test").description("Send a prompt through one configured brain role.").argument("<role>", "Brain role to invoke").argument("<prompt>", "Prompt to send").action(async (role, prompt) => {
-    const config = await loadConfig(import_node_process.default.cwd());
+    const config = await loadConfig(import_node_process2.default.cwd());
     if (!config) {
       requireConfigMessage();
     }
@@ -9078,10 +9574,10 @@ function createBrainsCommand() {
 }
 
 // src/commands/doctor.ts
-var import_node_process2 = __toESM(require("node:process"), 1);
-var import_node_child_process = require("node:child_process");
+var import_node_process3 = __toESM(require("node:process"), 1);
+var import_node_child_process2 = require("node:child_process");
 function commandVersion(binary) {
-  const result = (0, import_node_child_process.spawnSync)(binary, ["--version"], {
+  const result = (0, import_node_child_process2.spawnSync)(binary, ["--version"], {
     encoding: "utf8"
   });
   if (result.status === 0) {
@@ -9104,19 +9600,19 @@ function createDoctorCommand() {
       {
         name: "node",
         ok: true,
-        detail: import_node_process2.default.version
+        detail: import_node_process3.default.version
       },
       commandVersion("npm"),
       commandVersion("git"),
       commandVersion("docker")
     ];
-    const config = await loadConfig(import_node_process2.default.cwd());
-    const registry = createDefaultBrainProviderRegistry(import_node_process2.default.cwd());
+    const config = await loadConfig(import_node_process3.default.cwd());
+    const registry = createDefaultBrainProviderRegistry(import_node_process3.default.cwd());
     if (config) {
       checks.push({
         name: "config",
         ok: true,
-        detail: `${resolveConfigPath(import_node_process2.default.cwd())} (${config.providers.length} providers)`
+        detail: `${resolveConfigPath(import_node_process3.default.cwd())} (${config.providers.length} providers)`
       });
       for (const provider of config.providers) {
         try {
@@ -9153,7 +9649,7 @@ function createDoctorCommand() {
       checks.push({
         name: "config",
         ok: false,
-        detail: `missing (${resolveConfigPath(import_node_process2.default.cwd())})`
+        detail: `missing (${resolveConfigPath(import_node_process3.default.cwd())})`
       });
     }
     for (const check of checks) {
@@ -9163,13 +9659,13 @@ function createDoctorCommand() {
 }
 
 // src/commands/init.ts
-var import_node_process3 = __toESM(require("node:process"), 1);
+var import_node_process4 = __toESM(require("node:process"), 1);
 function createInitCommand() {
   return new Command("init").description("Create a local .kimbho/config.json file with an initial brain/provider setup.").option("--template <template>", "Provider template to use for the initial provider").option("--provider-id <id>", "Identifier for the initial provider").option("--driver <driver>", "Provider driver to use when no template is supplied").option("--label <label>", "Human-readable provider label").option("--model <model>", "Default model to use for planner/coder/reviewer brains").option("--fast-model <model>", "Model to use for the fast utility brain").option("--api-key-env <env>", "Environment variable that stores the provider API key").option("--base-url <url>", "Base URL or endpoint for the provider driver").option("--module-path <path>", "Module path for a custom provider driver").option("--force", "Overwrite an existing config file", false).action(async (options) => {
-    const existing = await loadConfig(import_node_process3.default.cwd());
+    const existing = await loadConfig(import_node_process4.default.cwd());
     if (existing && !options.force) {
       console.error("Config already exists. Re-run with --force to overwrite it.");
-      import_node_process3.default.exitCode = 1;
+      import_node_process4.default.exitCode = 1;
       return;
     }
     const templateId = options.template ?? (!options.driver ? "openai" : null);
@@ -9203,13 +9699,13 @@ function createInitCommand() {
       defaultModel: options.model ?? provider.defaultModel,
       fastModel: options.fastModel ?? options.model ?? provider.defaultModel
     });
-    const outputPath = await saveConfig(nextConfig, import_node_process3.default.cwd());
+    const outputPath = await saveConfig(nextConfig, import_node_process4.default.cwd());
     console.log(`Created ${outputPath}`);
   });
 }
 
 // src/commands/models.ts
-var import_node_process4 = __toESM(require("node:process"), 1);
+var import_node_process5 = __toESM(require("node:process"), 1);
 function parseInteger(value) {
   const parsed = Number.parseInt(value, 10);
   if (!Number.isFinite(parsed)) {
@@ -9249,18 +9745,26 @@ function renderModelLine(model) {
   ].filter((value) => Boolean(value));
   return details.length > 0 ? `${model.id} | ${details.join(" | ")}` : model.id;
 }
+function filterCachedModels(models, options) {
+  const normalizedSearch = options.search?.trim().toLowerCase();
+  const filtered = normalizedSearch ? models.filter((model) => model.id.toLowerCase().includes(normalizedSearch)) : models;
+  return typeof options.limit === "number" ? filtered.slice(0, options.limit) : filtered;
+}
 async function fetchProviderModels(provider, options) {
-  const cachedModels = provider.models.map((modelId) => ({
-    id: modelId,
-    providerId: provider.id
-  }));
+  const cachedModels = filterCachedModels(
+    provider.models.map((modelId) => ({
+      id: modelId,
+      providerId: provider.id
+    })),
+    options
+  );
   if (options.cached) {
     return {
       source: "cache",
       models: cachedModels
     };
   }
-  const registry = createDefaultBrainProviderRegistry(import_node_process4.default.cwd());
+  const registry = createDefaultBrainProviderRegistry(import_node_process5.default.cwd());
   try {
     const models = await registry.listModels(provider, {
       ...options.search ? {
@@ -9287,7 +9791,7 @@ async function fetchProviderModels(provider, options) {
 function createModelsCommand() {
   const command = new Command("models").description("Discover and select models from configured providers.");
   command.command("list").description("List models for one provider or all configured providers.").argument("[provider]", "Optional provider id to inspect").option("--search <term>", "Filter the returned models by search text").option("--limit <count>", "Maximum number of models to print", parseInteger, 25).option("--cached", "Use cached models from config instead of remote discovery", false).option("--sync", "Persist discovered model ids back into config", false).option("--json", "Print models as JSON", false).action(async (providerId, options) => {
-    let config = await loadConfig(import_node_process4.default.cwd());
+    let config = await loadConfig(import_node_process5.default.cwd());
     if (!config) {
       requireConfigMessage2();
     }
@@ -9316,7 +9820,7 @@ function createModelsCommand() {
       }
     }
     if (mutated) {
-      await saveConfig(config, import_node_process4.default.cwd());
+      await saveConfig(config, import_node_process5.default.cwd());
     }
     if (options.json) {
       console.log(renderJson(groups));
@@ -9333,7 +9837,7 @@ function createModelsCommand() {
     }
   });
   command.command("sync").description("Fetch remote models for one provider and cache the ids in config.").argument("<provider>", "Provider id to sync").option("--search <term>", "Optional search filter to limit what gets cached").option("--limit <count>", "Maximum number of models to cache", parseInteger, 200).action(async (providerId, options) => {
-    const config = await loadConfig(import_node_process4.default.cwd());
+    const config = await loadConfig(import_node_process5.default.cwd());
     if (!config) {
       requireConfigMessage2();
     }
@@ -9341,7 +9845,7 @@ function createModelsCommand() {
     if (!provider) {
       throw new Error(`Unknown provider "${providerId}".`);
     }
-    const registry = createDefaultBrainProviderRegistry(import_node_process4.default.cwd());
+    const registry = createDefaultBrainProviderRegistry(import_node_process5.default.cwd());
     const models = await registry.listModels(provider, {
       ...options.search ? {
         search: options.search
@@ -9352,12 +9856,12 @@ function createModelsCommand() {
       ...provider,
       models: Array.from(new Set(models.map((model) => model.id)))
     });
-    const outputPath = await saveConfig(nextConfig, import_node_process4.default.cwd());
+    const outputPath = await saveConfig(nextConfig, import_node_process5.default.cwd());
     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) => {
-    let config = await loadConfig(import_node_process4.default.cwd());
+    let config = await loadConfig(import_node_process5.default.cwd());
     if (!config) {
       requireConfigMessage2();
     }
@@ -9367,7 +9871,7 @@ function createModelsCommand() {
     }
     if (!options.force) {
       try {
-        const registry = createDefaultBrainProviderRegistry(import_node_process4.default.cwd());
+        const registry = createDefaultBrainProviderRegistry(import_node_process5.default.cwd());
         const models = await registry.listModels(provider, {
           search: model,
           limit: 500
@@ -9407,7 +9911,7 @@ function createModelsCommand() {
         } : {}
       });
     }
-    const outputPath = await saveConfig(config, import_node_process4.default.cwd());
+    const outputPath = await saveConfig(config, import_node_process5.default.cwd());
     console.log(`Updated ${outputPath}`);
     console.log(`Selected ${provider.id}/${model}`);
     if (options.role) {
@@ -9421,8 +9925,8 @@ function createModelsCommand() {
 }
 
 // src/commands/plan.ts
-var import_promises4 = require("node:fs/promises");
-var import_node_process5 = __toESM(require("node:process"), 1);
+var import_promises6 = require("node:fs/promises");
+var import_node_process6 = __toESM(require("node:process"), 1);
 
 // ../planner/dist/planner.js
 function normalizeGoal(goal) {
@@ -9726,7 +10230,7 @@ function createPlan(input) {
 
 // src/commands/plan.ts
 async function detectWorkspaceState(cwd) {
-  const entries = await (0, import_promises4.readdir)(cwd);
+  const entries = await (0, import_promises6.readdir)(cwd);
   const meaningfulEntries = entries.filter((entry) => entry !== ".kimbho" && !entry.startsWith("."));
   return meaningfulEntries.length === 0 ? "empty" : "existing";
 }
@@ -9737,7 +10241,7 @@ function createPlanCommand() {
     (value, previous = []) => [...previous, value],
     []
   ).option("--json", "Print the plan as JSON", false).action(async (goal, options) => {
-    const cwd = import_node_process5.default.cwd();
+    const cwd = import_node_process6.default.cwd();
     const request = {
       goal,
       mode: "plan",
@@ -9774,14 +10278,14 @@ function createPlanCommand() {
 }
 
 // src/commands/providers.ts
-var import_node_process6 = __toESM(require("node:process"), 1);
+var import_node_process7 = __toESM(require("node:process"), 1);
 function requireConfigMessage3() {
   throw new Error("No config found. Run `kimbho init` first.");
 }
 function createProvidersCommand() {
   const command = new Command("providers").description("Manage configured model providers and built-in templates.");
   command.command("list").description("List configured providers.").option("--json", "Print providers as JSON", false).action(async (options) => {
-    const config = await loadConfig(import_node_process6.default.cwd());
+    const config = await loadConfig(import_node_process7.default.cwd());
     if (!config) {
       requireConfigMessage3();
     }
@@ -9822,7 +10326,7 @@ function createProvidersCommand() {
     (value, previous = []) => [...previous, value],
     []
   ).option("--module-path <path>", "Module path for a custom provider driver").action(async (options) => {
-    const config = await loadConfig(import_node_process6.default.cwd());
+    const config = await loadConfig(import_node_process7.default.cwd());
     if (!config) {
       requireConfigMessage3();
     }
@@ -9856,16 +10360,16 @@ function createProvidersCommand() {
       } : {}
     });
     const nextConfig = upsertProvider(config, provider);
-    const outputPath = await saveConfig(nextConfig, import_node_process6.default.cwd());
+    const outputPath = await saveConfig(nextConfig, import_node_process7.default.cwd());
     console.log(`Updated ${outputPath}`);
     console.log(`Provider ${provider.id} -> ${provider.driver}`);
   });
   command.command("check").description("Run health checks for the configured providers.").action(async () => {
-    const config = await loadConfig(import_node_process6.default.cwd());
+    const config = await loadConfig(import_node_process7.default.cwd());
     if (!config) {
       requireConfigMessage3();
     }
-    const registry = createDefaultBrainProviderRegistry(import_node_process6.default.cwd());
+    const registry = createDefaultBrainProviderRegistry(import_node_process7.default.cwd());
     for (const provider of config.providers) {
       try {
         const result = await registry.healthCheck(provider);
@@ -9880,52 +10384,67 @@ function createProvidersCommand() {
 }
 
 // src/commands/resume.ts
-var import_node_process7 = __toESM(require("node:process"), 1);
+var import_node_process8 = __toESM(require("node:process"), 1);
+function parseCount(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`Expected a positive integer, received "${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).action(async (options) => {
-    const session = await loadLatestSession(import_node_process7.default.cwd());
+  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) => {
+    const cwd = import_node_process8.default.cwd();
+    const session = await loadLatestSession(cwd);
     if (!session) {
       console.error("No saved session found. Run `kimbho run` first.");
-      import_node_process7.default.exitCode = 1;
+      import_node_process8.default.exitCode = 1;
       return;
     }
+    const snapshot = options.execute ? await new ExecutionOrchestrator().continueSession(session, {
+      maxAutoTasks: options.maxAutoTasks
+    }) : session;
+    if (options.execute) {
+      await saveSession(snapshot, cwd);
+    }
     if (options.json) {
-      console.log(renderJson(session));
+      console.log(renderJson(snapshot));
       return;
     }
-    console.log(`Session: ${session.id}`);
-    console.log(`Goal: ${session.goal}`);
-    console.log(`Status: ${session.status}`);
-    console.log(`Ready tasks: ${session.readyTaskIds.join(", ") || "none"}`);
-    console.log(`Blocked tasks: ${session.blockedTaskIds.join(", ") || "none"}`);
-    console.log(`Assigned agents: ${session.assignedAgents.join(", ") || "none"}`);
-    console.log(`Notes: ${session.notes.join(" | ") || "none"}`);
+    console.log(renderSession(snapshot));
   });
 }
 
 // src/commands/run.ts
-var import_promises5 = require("node:fs/promises");
-var import_node_process8 = __toESM(require("node:process"), 1);
+var import_promises7 = require("node:fs/promises");
+var import_node_process9 = __toESM(require("node:process"), 1);
 async function detectWorkspaceState2(cwd) {
-  const entries = await (0, import_promises5.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";
 }
+function parseCount2(value) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed <= 0) {
+    throw new Error(`Expected a positive integer, received "${value}".`);
+  }
+  return parsed;
+}
 function createRunCommand() {
   return new Command("run").description("Create or load a plan, then open a runnable Kimbho session snapshot.").argument("[goal]", "Optional goal; if omitted, Kimbho will use the latest saved plan").option("--stack <stack>", "Preferred stack or preset").option(
     "--constraint <constraint>",
     "Explicit execution constraint; can be provided multiple times",
     (value, previous = []) => [...previous, value],
     []
-  ).option("--json", "Print the session snapshot as JSON", false).action(async (goal, options) => {
-    const cwd = import_node_process8.default.cwd();
+  ).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) => {
+    const cwd = import_node_process9.default.cwd();
     const orchestrator = new ExecutionOrchestrator();
     let request;
     let planPath = null;
     let plan = goal ? null : await loadLatestPlan(cwd);
     if (!plan && !goal) {
       console.error("No saved plan found. Pass a goal or run `kimbho plan` first.");
-      import_node_process8.default.exitCode = 1;
+      import_node_process9.default.exitCode = 1;
       return;
     }
     if (goal) {
@@ -9950,7 +10469,10 @@ function createRunCommand() {
       };
     }
     const envelope = orchestrator.buildEnvelope(request, plan);
-    const snapshot = orchestrator.createSessionSnapshot(envelope);
+    const initialSnapshot = orchestrator.createSessionSnapshot(envelope);
+    const snapshot = options.snapshotOnly ? initialSnapshot : await orchestrator.continueSession(initialSnapshot, {
+      maxAutoTasks: options.maxAutoTasks
+    });
     const sessionPath = await saveSession(snapshot, cwd);
     if (options.json) {
       console.log(
@@ -9964,15 +10486,12 @@ function createRunCommand() {
     }
     console.log(renderPlan(plan));
     console.log("");
-    console.log(`Session: ${snapshot.id}`);
-    console.log(`Saved session: ${sessionPath}`);
+    console.log(renderSession(snapshot));
+    console.log("");
     if (planPath) {
       console.log(`Saved plan: ${planPath}`);
     }
-    console.log(`Assigned agents: ${snapshot.assignedAgents.join(", ") || "none"}`);
-    console.log(`Ready tasks: ${snapshot.readyTaskIds.join(", ") || "none"}`);
-    console.log(`Blocked tasks: ${snapshot.blockedTaskIds.join(", ") || "none"}`);
-    console.log("Next step: wire executors into `run` so ready tasks can be acted on instead of only snapshotted.");
+    console.log(`Saved session: ${sessionPath}`);
   });
 }
 
@@ -10040,14 +10559,15 @@ function createProgram(onOpenShell) {
 }
 
 // src/shell.ts
-var import_promises6 = require("node:readline/promises");
-var import_node_process9 = __toESM(require("node:process"), 1);
+var import_promises8 = require("node:readline/promises");
+var import_node_process10 = __toESM(require("node:process"), 1);
 var AMBER = "\x1B[38;5;214m";
 var BOLD = "\x1B[1m";
 var DIM = "\x1B[2m";
 var RESET = "\x1B[0m";
 var TOP_LEVEL_COMMANDS = /* @__PURE__ */ new Set([
   "agents",
+  "brain",
   "brains",
   "doctor",
   "fix",
@@ -10057,15 +10577,30 @@ var TOP_LEVEL_COMMANDS = /* @__PURE__ */ new Set([
   "models",
   "new",
   "plan",
+  "provider",
   "providers",
   "quit",
   "resume",
   "review",
   "run",
   "scaffold",
+  "select",
   "shell",
-  "status"
+  "status",
+  "use-model"
 ]);
+var MODEL_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "help",
+  "list",
+  "sync",
+  "use"
+]);
+var BRAIN_ROLES = [
+  "planner",
+  "coder",
+  "reviewer",
+  "fast"
+];
 function color(code, value) {
   return `${code}${value}${RESET}`;
 }
@@ -10078,12 +10613,14 @@ function renderBanner() {
     "|_|\\_\\_|_|  |_|____/|____/|_| |_|\\___/ "
   ].map((line) => color(AMBER, line)).join("\n");
 }
-async function getShellSessionState(cwd) {
+async function getShellSessionState(cwd, focusRole) {
   const config = await loadConfig(cwd);
   if (!config) {
     return {
+      focusRole,
       providerLabel: "unconfigured",
       providerId: "-",
+      focusModel: "not set",
       coderModel: "not set",
       plannerModel: "not set",
       approvalMode: "manual",
@@ -10092,11 +10629,13 @@ async function getShellSessionState(cwd) {
       configured: false
     };
   }
-  const coderSettings = config.brains.coder;
-  const provider = findProviderById(config, coderSettings.providerId);
+  const focusSettings = config.brains[focusRole];
+  const provider = findProviderById(config, focusSettings.providerId);
   return {
+    focusRole,
     providerLabel: provider?.label ?? provider?.id ?? "unknown",
-    providerId: provider?.id ?? coderSettings.providerId,
+    providerId: provider?.id ?? focusSettings.providerId,
+    focusModel: resolveBrainModel(config, focusRole) ?? "not set",
     coderModel: resolveBrainModel(config, "coder") ?? "not set",
     plannerModel: resolveBrainModel(config, "planner") ?? "not set",
     approvalMode: config.approvalMode,
@@ -10129,20 +10668,24 @@ function renderBox(lines) {
 function renderHelp() {
   return [
     `${color(DIM, "Commands")}`,
-    "/status           Show the active model, provider, and workspace state.",
-    "/plan <goal>      Create a structured implementation plan.",
-    "/run <goal>       Start a Kimbho execution session for a goal.",
-    "/new <goal>       Alias for /run <goal>.",
-    "/scaffold <goal>  Alias for /run <goal> with scaffolding intent.",
-    "/resume           Show the latest saved session.",
-    "/agents           Inspect agent roles and the active session.",
-    "/providers        Manage model providers.",
-    "/model            Show the active planner/coder model selection.",
-    "/models           Discover and select provider models.",
-    "/brains           Inspect or assign planner/coder/reviewer brains.",
-    "/doctor           Check local environment and config.",
-    "/clear            Redraw the shell.",
-    "/quit, /exit      Leave the shell.",
+    "/status                  Show the active role, provider, and workspace state.",
+    "/brain <role>            Change shell focus to planner, coder, reviewer, or fast.",
+    "/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 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.",
+    "/plan <goal>             Create a structured implementation plan.",
+    "/run <goal>              Start a Kimbho execution session for a goal.",
+    "/resume                  Show the latest saved session.",
+    "/agents                  Inspect agent roles and the active session.",
+    "/doctor                  Check local environment and config.",
+    "/clear                   Redraw the shell.",
+    "/quit, /exit             Leave the shell.",
     "",
     `${color(DIM, "Tip")}`,
     "Type a natural-language goal directly and Kimbho will treat it as /run <goal>."
@@ -10151,6 +10694,8 @@ function renderHelp() {
 function renderStartupCard(cwd, state) {
   const cardLines = [
     `${color(BOLD, "Kimbho CLI")} (v${KIMBHO_VERSION})`,
+    renderCardLine("focus", state.focusRole),
+    renderCardLine("model", state.focusModel),
     renderCardLine("coder", state.coderModel),
     renderCardLine("planner", state.plannerModel),
     renderCardLine("provider", `${state.providerLabel} [${state.providerId}]`),
@@ -10158,23 +10703,23 @@ function renderStartupCard(cwd, state) {
     renderCardLine("approval", state.approvalMode),
     renderCardLine("sandbox", state.sandboxMode),
     renderCardLine("preset", state.stackPreset),
-    renderCardLine("shortcuts", "/help  /status  /plan  /run  /models  /brains  /quit")
+    renderCardLine("shortcuts", "/brain  /providers  /models  /select  /use-model  /quit")
   ];
   if (!state.configured) {
-    cardLines.push("setup: run /init to create .kimbho/config.json");
+    cardLines.push("setup: run /init or /providers add <template> to create .kimbho/config.json");
   }
   return renderBox(cardLines);
 }
 function formatPrompt(state) {
-  const coderModel = state.coderModel === "not set" ? "unconfigured" : shortenMiddle(state.coderModel, 18);
-  return `${color(AMBER, "kimbho")} ${color(DIM, `[${coderModel}]`)} > `;
+  const model = state.focusModel === "not set" ? "unconfigured" : shortenMiddle(state.focusModel, 18);
+  return `${color(AMBER, "kimbho")} ${color(DIM, `[${state.focusRole}:${model}]`)} > `;
 }
 function printHeader(cwd, state) {
   console.log(renderBanner());
   console.log(color(DIM, "Terminal-native coding agent"));
   console.log(renderStartupCard(cwd, state));
   console.log("");
-  console.log(color(DIM, "Tip: describe the app or repo change you want, and Kimbho will route it into /run."));
+  console.log(color(DIM, "Tip: configure providers and models here, then describe the work and Kimbho will route it into /run."));
   console.log(renderHelp());
   console.log("");
 }
@@ -10225,21 +10770,399 @@ function tokenizeInput(input) {
   }
   return tokens;
 }
-function toCommandTokens(input) {
+function normalizeInputTokens(input) {
   const trimmed = input.trim();
   if (!trimmed) {
-    return [];
+    return {
+      normalizedInput: "",
+      tokens: [],
+      head: null
+    };
   }
   const normalizedInput = trimmed.startsWith("kimbho ") ? trimmed.slice("kimbho ".length).trim() : trimmed;
   const tokens = tokenizeInput(normalizedInput);
-  if (tokens.length === 0) {
+  const firstToken = tokens[0];
+  if (!firstToken) {
+    return {
+      normalizedInput,
+      tokens,
+      head: null
+    };
+  }
+  return {
+    normalizedInput,
+    tokens,
+    head: firstToken.startsWith("/") ? firstToken.slice(1) : firstToken
+  };
+}
+function defaultProviderIdForTemplate(templateId) {
+  switch (templateId) {
+    case "openai":
+      return "openai-main";
+    case "anthropic":
+      return "anthropic-main";
+    case "openrouter":
+      return "openrouter-main";
+    case "ollama":
+      return "ollama-local";
+    case "lmstudio":
+      return "lmstudio-local";
+    default:
+      return `${templateId}-main`;
+  }
+}
+function buildCachedModels(provider, search, limit = 25) {
+  const normalized = search?.trim().toLowerCase();
+  const filtered = normalized ? provider.models.filter((modelId) => modelId.toLowerCase().includes(normalized)) : provider.models;
+  return filtered.slice(0, limit).map((modelId) => ({
+    id: modelId,
+    providerId: provider.id
+  }));
+}
+async function fetchModelsForProvider(cwd, config, provider, search, limit = 25) {
+  const registry = createDefaultBrainProviderRegistry(cwd);
+  const cachedModels = buildCachedModels(provider, search, limit);
+  try {
+    const models = await registry.listModels(provider, {
+      ...search ? {
+        search
+      } : {},
+      limit
+    });
+    const nextConfig = upsertProvider(config, {
+      ...provider,
+      models: Array.from(/* @__PURE__ */ new Set([
+        ...provider.models,
+        ...models.map((model) => model.id)
+      ]))
+    });
+    if (nextConfig !== config) {
+      await saveConfig(nextConfig, cwd);
+    }
+    return {
+      config: nextConfig,
+      source: "remote",
+      models
+    };
+  } catch (error) {
+    if (cachedModels.length > 0) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        config,
+        source: "cache",
+        note: `Using cached models because remote discovery failed: ${message}`,
+        models: cachedModels
+      };
+    }
+    throw error;
+  }
+}
+async function assignModelToRole(cwd, role, providerId, model) {
+  const config = await loadConfig(cwd);
+  if (!config) {
+    throw new Error("No config found. Run /init or /providers add first.");
+  }
+  const provider = findProviderById(config, providerId);
+  if (!provider) {
+    throw new Error(`Unknown provider "${providerId}".`);
+  }
+  const currentSettings = resolveBrainSettings(config, role);
+  const nextConfig = assignBrain(
+    upsertProvider(config, {
+      ...provider,
+      defaultModel: model,
+      models: Array.from(/* @__PURE__ */ new Set([
+        ...provider.models,
+        model
+      ]))
+    }),
+    role,
+    {
+      providerId,
+      model,
+      ...typeof currentSettings.temperature === "number" ? {
+        temperature: currentSettings.temperature
+      } : {},
+      ...typeof currentSettings.maxTokens === "number" ? {
+        maxTokens: currentSettings.maxTokens
+      } : {},
+      ...currentSettings.promptPreamble ? {
+        promptPreamble: currentSettings.promptPreamble
+      } : {}
+    }
+  );
+  const outputPath = await saveConfig(nextConfig, cwd);
+  return outputPath;
+}
+async function useProviderForRole(cwd, role, providerId) {
+  const config = await loadConfig(cwd);
+  if (!config) {
+    throw new Error("No config found. Run /init or /providers add first.");
+  }
+  const provider = findProviderById(config, 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 outputPath = await saveConfig(nextConfig, cwd);
+  return {
+    outputPath,
+    model: resolvedModel
+  };
+}
+function renderModelLine2(model) {
+  const details = [
+    model.name,
+    model.contextLength ? `ctx ${model.contextLength}` : null,
+    model.promptPrice ? `in ${model.promptPrice}` : null,
+    model.completionPrice ? `out ${model.completionPrice}` : null,
+    model.modality
+  ].filter((value) => Boolean(value));
+  return details.length > 0 ? `${model.id} | ${details.join(" | ")}` : model.id;
+}
+async function printProviderList(cwd, focusRole) {
+  const config = await loadConfig(cwd);
+  if (!config) {
+    console.log("No config found. Run /init or /providers add <template> first.");
+    return;
+  }
+  const activeProviderId = config.brains[focusRole].providerId;
+  for (const provider of config.providers) {
+    const marker = provider.id === activeProviderId ? "*" : " ";
+    const envState = provider.apiKeyEnv ? import_node_process10.default.env[provider.apiKeyEnv] ? "present" : `missing ${provider.apiKeyEnv}` : "no key required";
+    console.log(`${marker} ${provider.id}`);
+    console.log(`  label: ${provider.label ?? "-"}`);
+    console.log(`  driver: ${provider.driver}`);
+    console.log(`  model: ${provider.defaultModel ?? "-"}`);
+    console.log(`  auth: ${envState}`);
+    console.log(`  cachedModels: ${provider.models.length}`);
+  }
+}
+function printProviderTemplates() {
+  for (const template of listProviderTemplates()) {
+    console.log(`${template.id}`);
+    console.log(`  label: ${template.label}`);
+    console.log(`  driver: ${template.driver}`);
+    console.log(`  apiKeyEnv: ${template.defaultApiKeyEnv ?? "-"}`);
+    console.log(`  model: ${template.defaultModel ?? "-"}`);
+    console.log(`  notes: ${template.notes}`);
+  }
+}
+async function addProviderFromTemplate(cwd, templateId, providerId) {
+  const provider = buildProviderFromTemplate(templateId, {
+    providerId: providerId ?? defaultProviderIdForTemplate(templateId)
+  });
+  const config = await loadConfig(cwd);
+  if (!config) {
+    const outputPath = await saveConfig(createDefaultConfig({ provider }), cwd);
+    return outputPath;
+  }
+  return saveConfig(upsertProvider(config, provider), cwd);
+}
+async function printProviderHealth(cwd) {
+  const config = await loadConfig(cwd);
+  if (!config) {
+    console.log("No config found. Run /init or /providers add <template> first.");
+    return;
+  }
+  const registry = createDefaultBrainProviderRegistry(cwd);
+  for (const provider of config.providers) {
+    try {
+      const result = await registry.healthCheck(provider);
+      console.log(`${result.ok ? "PASS" : "FAIL"} ${provider.id}: ${provider.driver} | ${result.message}`);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.log(`FAIL ${provider.id}: ${provider.driver} | ${message}`);
+    }
+  }
+}
+async function printBrainAssignments(cwd) {
+  const config = await loadConfig(cwd);
+  if (!config) {
+    console.log("No config found. Run /init or /providers add <template> first.");
+    return;
+  }
+  for (const role of BRAIN_ROLES) {
+    const settings = resolveBrainSettings(config, role);
+    console.log(`${role}`);
+    console.log(`  provider: ${settings.providerId}`);
+    console.log(`  model: ${resolveBrainModel(config, role) ?? "-"}`);
+    console.log(`  temperature: ${settings.temperature ?? "-"}`);
+    console.log(`  maxTokens: ${settings.maxTokens ?? "-"}`);
+  }
+}
+function isBrainRole(value) {
+  return BRAIN_ROLES.includes(value);
+}
+async function handleProvidersCommand(cwd, tokens, runtime) {
+  const subcommand = tokens[1];
+  if (!subcommand || subcommand === "list") {
+    await printProviderList(cwd, runtime.focusRole);
+    return;
+  }
+  if (subcommand === "templates") {
+    printProviderTemplates();
+    return;
+  }
+  if (subcommand === "check") {
+    await printProviderHealth(cwd);
+    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);
+    console.log(`Updated ${outputPath}`);
+    console.log(`Added provider ${resolvedProviderId} from template ${templateId}`);
+    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]");
+    }
+    const targetRole = role && isBrainRole(role) ? role : runtime.focusRole;
+    const result = await useProviderForRole(cwd, targetRole, providerId);
+    runtime.focusRole = targetRole;
+    runtime.lastModels = null;
+    console.log(`Updated ${result.outputPath}`);
+    console.log(`Focus role ${targetRole} now uses provider ${providerId}${result.model ? ` (${result.model})` : ""}`);
+    return;
+  }
+  throw new Error("Usage: /providers [list|templates|add|use|check]");
+}
+async function handleBrainCommand(cwd, tokens, runtime) {
+  const subcommand = tokens[1];
+  if (!subcommand || subcommand === "list") {
+    await printBrainAssignments(cwd);
+    return;
+  }
+  if (subcommand === "use" && tokens[2] && isBrainRole(tokens[2])) {
+    runtime.focusRole = tokens[2];
+    runtime.lastModels = null;
+    console.log(`Shell focus role is now ${runtime.focusRole}.`);
+    return;
+  }
+  if (isBrainRole(subcommand)) {
+    runtime.focusRole = subcommand;
+    runtime.lastModels = null;
+    console.log(`Shell focus role is now ${runtime.focusRole}.`);
+    return;
+  }
+  throw new Error("Usage: /brain [planner|coder|reviewer|fast]");
+}
+async function handleModelsCommand(cwd, tokens, runtime) {
+  const config = await loadConfig(cwd);
+  if (!config) {
+    throw new Error("No config found. Run /init or /providers add <template> first.");
+  }
+  const providerId = config.brains[runtime.focusRole].providerId;
+  const provider = findProviderById(config, providerId);
+  if (!provider) {
+    throw new Error(`Active role "${runtime.focusRole}" points to unknown provider "${providerId}".`);
+  }
+  const subcommand = tokens[1];
+  if (subcommand === "use") {
+    const modelId = tokens.slice(2).join(" ").trim();
+    if (!modelId) {
+      throw new Error("Usage: /models use <model-id>");
+    }
+    const outputPath = await assignModelToRole(cwd, runtime.focusRole, provider.id, modelId);
+    console.log(`Updated ${outputPath}`);
+    console.log(`Selected ${provider.id}/${modelId}`);
+    console.log(`Assigned role ${runtime.focusRole}`);
+    return;
+  }
+  const search = !subcommand || MODEL_SUBCOMMANDS.has(subcommand) ? void 0 : tokens.slice(1).join(" ");
+  const result = await fetchModelsForProvider(cwd, config, provider, search, 25);
+  runtime.lastModels = {
+    providerId: provider.id,
+    role: runtime.focusRole,
+    source: result.source,
+    ...search ? {
+      search
+    } : {},
+    models: result.models
+  };
+  console.log(`${provider.id} (${result.source})`);
+  if (result.note) {
+    console.log(`  note: ${result.note}`);
+  }
+  if (result.models.length === 0) {
+    console.log("  no models found");
+    return;
+  }
+  for (const [index, model] of result.models.entries()) {
+    console.log(`  ${index + 1}. ${renderModelLine2(model)}`);
+  }
+  console.log(``);
+  console.log(`Use /select <number> or /use-model <model-id> to assign one to ${runtime.focusRole}.`);
+}
+async function handleModelSelection(cwd, modelId, runtime) {
+  const config = await loadConfig(cwd);
+  if (!config) {
+    throw new Error("No config found. Run /init or /providers add <template> first.");
+  }
+  const providerId = config.brains[runtime.focusRole].providerId;
+  const provider = findProviderById(config, providerId);
+  if (!provider) {
+    throw new Error(`Active role "${runtime.focusRole}" points to unknown provider "${providerId}".`);
+  }
+  const outputPath = await assignModelToRole(cwd, runtime.focusRole, provider.id, modelId);
+  console.log(`Updated ${outputPath}`);
+  console.log(`Selected ${provider.id}/${modelId}`);
+  console.log(`Assigned role ${runtime.focusRole}`);
+}
+async function handleSelectCommand(cwd, tokens, runtime) {
+  const rawIndex = tokens[1];
+  if (!rawIndex) {
+    throw new Error("Usage: /select <number>");
+  }
+  if (!runtime.lastModels || runtime.lastModels.models.length === 0) {
+    throw new Error("No model list is active. Run /models first.");
+  }
+  const index = Number.parseInt(rawIndex, 10);
+  if (!Number.isInteger(index) || index <= 0) {
+    throw new Error(`Expected a positive model number, received "${rawIndex}".`);
+  }
+  const model = runtime.lastModels.models[index - 1];
+  if (!model) {
+    throw new Error(`Model number ${index} is out of range.`);
+  }
+  runtime.focusRole = runtime.lastModels.role;
+  await handleModelSelection(cwd, model.id, runtime);
+}
+function toExternalCommandTokens(input, state) {
+  const { normalizedInput, tokens, head } = normalizeInputTokens(input);
+  if (!head || tokens.length === 0) {
     return [];
   }
   const firstToken = tokens[0];
   if (!firstToken) {
     return [];
   }
-  const head = firstToken.startsWith("/") ? firstToken.slice(1) : firstToken;
   if (head === "new") {
     return [
       "run",
@@ -10253,12 +11176,6 @@ function toCommandTokens(input) {
       `scaffold ${goal}`.trim()
     ];
   }
-  if (head === "model") {
-    return [
-      "brains",
-      "list"
-    ];
-  }
   if (!firstToken.startsWith("/") && !TOP_LEVEL_COMMANDS.has(head) && !head.startsWith("-")) {
     return [
       "run",
@@ -10268,91 +11185,157 @@ function toCommandTokens(input) {
   tokens[0] = head;
   return tokens;
 }
+async function handleShellCommand(cwd, input, state, runtime, execute) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    return;
+  }
+  if (trimmed === "/exit" || trimmed === "exit" || trimmed === "quit" || trimmed === "/quit") {
+    throw new Error("__kimbho_exit__");
+  }
+  if (trimmed === "/help" || trimmed === "help" || trimmed === "?") {
+    console.log(renderHelp());
+    return;
+  }
+  if (trimmed === "/status" || trimmed === "status") {
+    console.log(renderStartupCard(cwd, state));
+    return;
+  }
+  if (trimmed === "/clear" || trimmed === "clear") {
+    if (import_node_process10.default.stdout.isTTY) {
+      import_node_process10.default.stdout.write("\x1Bc");
+    }
+    const nextState = await getShellSessionState(cwd, runtime.focusRole);
+    printHeader(cwd, nextState);
+    return;
+  }
+  const { tokens, head } = normalizeInputTokens(trimmed);
+  if (!head) {
+    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("-");
+    if (canHandleLocally) {
+      await handleProvidersCommand(cwd, [
+        "providers",
+        ...tokens.slice(1)
+      ], runtime);
+      return;
+    }
+  }
+  if (head === "brain" || head === "brains") {
+    const subcommand = tokens[1];
+    const roleArg = tokens[2];
+    const canHandleLocally = !subcommand || subcommand === "list" || isBrainRole(subcommand) || subcommand === "use" && (roleArg ? isBrainRole(roleArg) : false);
+    if (canHandleLocally) {
+      await handleBrainCommand(cwd, [
+        "brain",
+        ...tokens.slice(1)
+      ], runtime);
+      return;
+    }
+  }
+  if (head === "model") {
+    await printBrainAssignments(cwd);
+    return;
+  }
+  if (head === "models") {
+    await handleModelsCommand(cwd, [
+      "models",
+      ...tokens.slice(1)
+    ], runtime);
+    return;
+  }
+  if (head === "use-model") {
+    const modelId = tokens.slice(1).join(" ").trim();
+    if (!modelId) {
+      throw new Error("Usage: /use-model <model-id>");
+    }
+    await handleModelSelection(cwd, modelId, runtime);
+    return;
+  }
+  if (head === "select") {
+    await handleSelectCommand(cwd, [
+      "select",
+      ...tokens.slice(1)
+    ], runtime);
+    return;
+  }
+  const externalTokens = toExternalCommandTokens(trimmed, state);
+  if (externalTokens.length === 0) {
+    return;
+  }
+  await execute(externalTokens);
+}
 async function runInteractiveShell(options) {
-  const readline = (0, import_promises6.createInterface)({
-    input: import_node_process9.default.stdin,
-    output: import_node_process9.default.stdout,
-    terminal: Boolean(import_node_process9.default.stdin.isTTY && import_node_process9.default.stdout.isTTY)
+  const readline = (0, import_promises8.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
+  };
   let closed = false;
   readline.on("SIGINT", () => {
     closed = true;
     readline.close();
   });
-  let state = await getShellSessionState(options.cwd);
+  let state = await getShellSessionState(options.cwd, runtime.focusRole);
   printHeader(options.cwd, state);
   while (!closed) {
     let line;
     try {
-      state = await getShellSessionState(options.cwd);
+      state = await getShellSessionState(options.cwd, runtime.focusRole);
       line = await readline.question(formatPrompt(state));
     } catch {
       break;
     }
-    const trimmed = line.trim();
-    if (!trimmed) {
-      continue;
-    }
-    if (trimmed === "/exit" || trimmed === "exit" || trimmed === "quit" || trimmed === "/quit") {
-      closed = true;
-      break;
-    }
-    if (trimmed === "/help" || trimmed === "help" || trimmed === "?") {
-      console.log(renderHelp());
-      console.log("");
-      continue;
-    }
-    if (trimmed === "/status" || trimmed === "status") {
-      state = await getShellSessionState(options.cwd);
-      console.log(renderStartupCard(options.cwd, state));
-      console.log("");
-      continue;
-    }
-    if (trimmed === "/clear" || trimmed === "clear") {
-      if (import_node_process9.default.stdout.isTTY) {
-        import_node_process9.default.stdout.write("\x1Bc");
-      }
-      state = await getShellSessionState(options.cwd);
-      printHeader(options.cwd, state);
-      continue;
-    }
     try {
-      const tokens = toCommandTokens(trimmed);
-      if (tokens.length === 0) {
-        continue;
-      }
-      await options.execute(tokens);
+      await handleShellCommand(options.cwd, line, state, runtime, options.execute);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
+      if (message === "__kimbho_exit__") {
+        closed = true;
+        break;
+      }
       console.error(message);
     } finally {
-      import_node_process9.default.exitCode = 0;
+      import_node_process10.default.exitCode = 0;
     }
     if (!closed) {
       console.log("");
     }
   }
   readline.close();
-  import_node_process9.default.exitCode = 0;
+  import_node_process10.default.exitCode = 0;
   console.log(color(DIM, "Leaving Kimbho."));
 }
 
 // src/index.ts
 async function dispatchCliTokens(tokens) {
-  const program2 = createProgram();
-  program2.exitOverride();
-  try {
-    await program2.parseAsync([
-      "node",
-      "kimbho",
-      ...normalizeCliTokens(tokens)
-    ]);
-  } catch (error) {
-    if (error instanceof CommanderError) {
-      return;
-    }
-    throw error;
-  }
+  const normalizedTokens = normalizeCliTokens(tokens);
+  await new Promise((resolve, reject) => {
+    const child = (0, import_node_child_process3.spawn)(
+      process.execPath,
+      [
+        ...process.execArgv,
+        process.argv[1] ?? "",
+        ...normalizedTokens
+      ],
+      {
+        cwd: process.cwd(),
+        env: process.env,
+        stdio: "inherit"
+      }
+    );
+    child.on("error", reject);
+    child.on("close", () => {
+      resolve();
+    });
+  });
 }
 async function openShell() {
   await runInteractiveShell({