@kimbho/kimbho-cli 0.1.1 → 0.1.2

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.2",
   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) {
@@ -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)) {
@@ -9260,7 +9756,7 @@ async function fetchProviderModels(provider, options) {
       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 +9783,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 +9812,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 +9829,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 +9837,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 +9848,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 +9863,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 +9903,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 +9917,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 +10222,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 +10233,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 +10270,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 +10318,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 +10352,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 +10376,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 +10461,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 +10478,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,8 +10551,8 @@ 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";
@@ -10269,10 +10780,10 @@ function toCommandTokens(input) {
   return tokens;
 }
 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)
   });
   let closed = false;
   readline.on("SIGINT", () => {
@@ -10309,8 +10820,8 @@ async function runInteractiveShell(options) {
       continue;
     }
     if (trimmed === "/clear" || trimmed === "clear") {
-      if (import_node_process9.default.stdout.isTTY) {
-        import_node_process9.default.stdout.write("\x1Bc");
+      if (import_node_process10.default.stdout.isTTY) {
+        import_node_process10.default.stdout.write("\x1Bc");
       }
       state = await getShellSessionState(options.cwd);
       printHeader(options.cwd, state);
@@ -10326,33 +10837,39 @@ async function runInteractiveShell(options) {
       const message = error instanceof Error ? error.message : String(error);
       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({