@kimbho/kimbho-cli 0.1.6 → 0.1.7

package/dist/index.cjs

@@ -1147,7 +1147,7 @@ var require_command = __commonJS({
   "../../node_modules/commander/lib/command.js"(exports2) {
     var EventEmitter = require("node:events").EventEmitter;
     var childProcess = require("node:child_process");
-    var path13 = require("node:path");
+    var path14 = require("node:path");
     var fs = require("node:fs");
     var process14 = require("node:process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -2147,9 +2147,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path13.resolve(baseDir, baseName);
+          const localBin = path14.resolve(baseDir, baseName);
           if (fs.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path13.extname(baseName))) return void 0;
+          if (sourceExt.includes(path14.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 = path13.resolve(
-            path13.dirname(resolvedScriptPath),
+          executableDir = path14.resolve(
+            path14.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path13.basename(
+            const legacyName = path14.basename(
               this._scriptPath,
-              path13.extname(this._scriptPath)
+              path14.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2188,7 +2188,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path13.extname(executableFile));
+        launchWithNode = sourceExt.includes(path14.extname(executableFile));
         let proc;
         if (process14.platform !== "win32") {
           if (launchWithNode) {
@@ -3035,7 +3035,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path13.basename(filename, path13.extname(filename));
+        this._name = path14.basename(filename, path14.extname(filename));
         return this;
       }
       /**
@@ -3049,9 +3049,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path14) {
-        if (path14 === void 0) return this._executableDir;
-        this._executableDir = path14;
+      executableDir(path15) {
+        if (path15 === void 0) return this._executableDir;
+        this._executableDir = path15;
         return this;
       }
       /**
@@ -3346,7 +3346,7 @@ var {
 // package.json
 var package_default = {
   name: "@kimbho/kimbho-cli",
-  version: "0.1.6",
+  version: "0.1.7",
   description: "Kimbho CLI is a terminal-native coding agent for planning, execution, and verification.",
   type: "module",
   engines: {
@@ -4140,8 +4140,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path13, errorMaps, issueData } = params;
-  const fullPath = [...path13, ...issueData.path || []];
+  const { data, path: path14, errorMaps, issueData } = params;
+  const fullPath = [...path14, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -4257,11 +4257,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path13, key) {
+  constructor(parent, value, path14, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path13;
+    this._path = path14;
     this._key = key;
   }
   get path() {
@@ -9353,9 +9353,15 @@ var AutonomousTaskExecutor = class {
         try {
           result = await this.toolRuntime.run(toolId, input, options.signal ? {
             cwd: request.cwd,
-            signal: options.signal
+            signal: options.signal,
+            approvalMode: this.config.approvalMode,
+            sandboxMode: this.config.sandboxMode,
+            agentRole: task.agentRole
           } : {
-            cwd: request.cwd
+            cwd: request.cwd,
+            approvalMode: this.config.approvalMode,
+            sandboxMode: this.config.sandboxMode,
+            agentRole: task.agentRole
           });
         } catch (error) {
           if (isAbortError(error)) {
@@ -9639,9 +9645,15 @@ var AutonomousTaskExecutor = class {
       try {
         result = await this.toolRuntime.run(parsedAction.tool, parsedAction.input, options.signal ? {
           cwd: request.cwd,
-          signal: options.signal
+          signal: options.signal,
+          approvalMode: this.config.approvalMode,
+          sandboxMode: this.config.sandboxMode,
+          agentRole: task.agentRole
         } : {
-          cwd: request.cwd
+          cwd: request.cwd,
+          approvalMode: this.config.approvalMode,
+          sandboxMode: this.config.sandboxMode,
+          agentRole: task.agentRole
         });
       } catch (error) {
         if (isAbortError(error)) {
@@ -10740,7 +10752,12 @@ async function loadTypeScript() {
   return module2;
 }
 async function walkWorkspace(root, current = root, results = []) {
-  const entries = await (0, import_promises7.readdir)(current, { withFileTypes: true });
+  const entries = await (0, import_promises7.readdir)(current, { withFileTypes: true }).catch((error) => {
+    if (error.code === "EACCES" || error.code === "EPERM" || error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  });
   for (const entry of entries) {
     const fullPath = import_node_path7.default.join(current, entry.name);
     const relativePath = import_node_path7.default.relative(root, fullPath);
@@ -11627,6 +11644,111 @@ function resolveWorkspacePath(cwd, filePath) {
   }
   return resolved;
 }
+var READ_ONLY_SHELL_PREFIXES = [
+  "pwd",
+  "ls",
+  "find ",
+  "rg ",
+  "grep ",
+  "cat ",
+  "sed ",
+  "head ",
+  "tail ",
+  "git status",
+  "git diff",
+  "git rev-parse",
+  "git branch",
+  "git log",
+  "git show",
+  "npm ls",
+  "pnpm ls",
+  "yarn list"
+];
+var DESTRUCTIVE_SHELL_PATTERNS = [
+  /\brm\s+-rf\b/i,
+  /\brm\s+-fr\b/i,
+  /\bgit\s+reset\s+--hard\b/i,
+  /\bgit\s+clean\s+-f(d|x|fd|fdx)\b/i,
+  /\bgit\s+checkout\s+--\b/i,
+  /\bmv\s+.+\s+\/dev\/null\b/i,
+  /\bdd\s+if=/i,
+  /\bmkfs(\.| )/i,
+  /\bsudo\b/i
+];
+var PROTECTED_WRITE_PREFIXES = [
+  ".git",
+  ".kimbho/config.json",
+  ".kimbho/sessions",
+  ".kimbho/plans"
+];
+function isReadOnlyShellCommand2(command) {
+  const normalized = command.trim().toLowerCase();
+  return READ_ONLY_SHELL_PREFIXES.some((prefix) => normalized === prefix || normalized.startsWith(prefix));
+}
+function isDestructiveShellCommand(command) {
+  return DESTRUCTIVE_SHELL_PATTERNS.some((pattern) => pattern.test(command));
+}
+function normalizeArtifactRelativePath(cwd, absolutePath) {
+  const relative = import_node_path9.default.relative(cwd, absolutePath) || import_node_path9.default.basename(absolutePath);
+  return relative.replace(/\\/g, "/");
+}
+function isProtectedWritePath(relativePath) {
+  return PROTECTED_WRITE_PREFIXES.some((prefix) => relativePath === prefix || relativePath.startsWith(`${prefix}/`));
+}
+function extractProspectiveWriteTargets(toolId, input, cwd) {
+  if (toolId === "file.write" && typeof input.path === "string") {
+    return [
+      normalizeArtifactRelativePath(cwd, resolveWorkspacePath(cwd, input.path))
+    ];
+  }
+  if (toolId === "file.patch" && typeof input.patch === "string") {
+    return extractPatchArtifacts(cwd, input.patch).map((artifactPath) => normalizeArtifactRelativePath(cwd, artifactPath));
+  }
+  if (toolId === "scaffold.generate") {
+    return [
+      "(scaffold workspace)"
+    ];
+  }
+  return [];
+}
+function createPolicyFailure(toolId, reason) {
+  return ToolResultSchema.parse({
+    toolId,
+    success: false,
+    summary: reason,
+    stderr: reason,
+    artifacts: []
+  });
+}
+function enforceToolPolicy(toolId, input, descriptor, context) {
+  if (!descriptor) {
+    return null;
+  }
+  const sandboxMode = context.sandboxMode ?? "workspace-write";
+  const approvalMode = context.approvalMode ?? "manual";
+  const command = typeof input.command === "string" ? input.command : "";
+  if (sandboxMode === "read-only") {
+    if (toolId === "shell.exec" && isReadOnlyShellCommand2(command)) {
+      return null;
+    }
+    if (descriptor.permission !== "safe") {
+      return createPolicyFailure(toolId, `Blocked ${toolId} because sandbox mode is read-only.`);
+    }
+  }
+  if (toolId === "shell.exec" && isDestructiveShellCommand(command)) {
+    if (!context.operatorApproved && approvalMode !== "auto") {
+      return createPolicyFailure(toolId, `Blocked destructive shell command under manual approval mode: ${command}`);
+    }
+  }
+  if ((toolId === "file.write" || toolId === "file.patch") && sandboxMode === "workspace-write") {
+    const targets = extractProspectiveWriteTargets(toolId, input, context.cwd);
+    const protectedTargets = targets.filter((target) => isProtectedWritePath(target));
+    if (protectedTargets.length > 0) {
+      return createPolicyFailure(toolId, `Blocked write to protected workspace paths: ${protectedTargets.join(", ")}`);
+    }
+  }
+  return null;
+}
 async function runSpawn(command, args, cwd, timeoutMs, signal) {
   return new Promise((resolve, reject) => {
     if (signal?.aborted) {
@@ -12447,6 +12569,10 @@ var ToolRuntime = class {
     if (!executor) {
       throw new Error(`No executor registered for "${toolId}".`);
     }
+    const policyFailure = enforceToolPolicy(toolId, input, descriptor, context);
+    if (policyFailure) {
+      return policyFailure;
+    }
     return executor(input, context, descriptor.timeoutMs);
   }
 };
@@ -12747,6 +12873,66 @@ async function cleanupWorktree(cwd, worktreePath, signal) {
     force: true
   });
 }
+async function writeConflictBundle(input) {
+  await ensureKimbhoDir(input.mainCwd);
+  const logsDir = import_node_path10.default.join(resolveKimbhoDir(input.mainCwd), "logs");
+  const baseName = import_node_path10.default.basename(input.originalPatchArtifactPath, ".patch");
+  const outputPath = import_node_path10.default.join(logsDir, `${baseName}-integration-conflict.md`);
+  const lines = [
+    "# Integration Conflict",
+    "",
+    `- summary: ${input.summary}`,
+    `- original patch: ${input.originalPatchArtifactPath}`,
+    ...input.refreshedPatchArtifactPath ? [
+      `- refreshed patch: ${input.refreshedPatchArtifactPath}`
+    ] : [],
+    `- changed files: ${input.changedFiles.length > 0 ? input.changedFiles.join(", ") : "(unknown)"}`,
+    "",
+    "## Notes",
+    ...input.notes.map((note) => `- ${note}`),
+    ""
+  ];
+  if (input.directApplyStdout || input.directApplyStderr) {
+    lines.push("## Direct Apply");
+    if (input.directApplyStdout) {
+      lines.push("");
+      lines.push("```text");
+      lines.push(input.directApplyStdout);
+      lines.push("```");
+    }
+    if (input.directApplyStderr) {
+      lines.push("");
+      lines.push("```text");
+      lines.push(input.directApplyStderr);
+      lines.push("```");
+    }
+    lines.push("");
+  }
+  if (input.replayStdout || input.replayStderr) {
+    lines.push("## Replay Attempt");
+    if (input.replayStdout) {
+      lines.push("");
+      lines.push("```text");
+      lines.push(input.replayStdout);
+      lines.push("```");
+    }
+    if (input.replayStderr) {
+      lines.push("");
+      lines.push("```text");
+      lines.push(input.replayStderr);
+      lines.push("```");
+    }
+    lines.push("");
+  }
+  lines.push("## Operator Next Steps");
+  lines.push("- Inspect the original patch and the refreshed patch if present.");
+  lines.push("- Compare the listed changed files against the current workspace diff.");
+  lines.push("- Resolve the conflict manually or re-run the task after adjusting overlapping files.");
+  lines.push("");
+  await (0, import_promises10.writeFile)(outputPath, `${lines.join("\n")}
+`, "utf8");
+  return outputPath;
+}
 async function readTextFileIfPresent(filePath) {
   return (0, import_promises10.readFile)(filePath, "utf8").catch((error) => {
     if (error.code === "ENOENT") {
@@ -12848,6 +13034,16 @@ async function createReplayWorktree(cwd, basePatchArtifactPath, signal) {
 async function replayPatchOnLatestWorkspace(mainCwd, sourceWorktreePath, originalPatchArtifactPath, changedFilesSummary, signal) {
   const replayWorktree = await createReplayWorktree(mainCwd, originalPatchArtifactPath, signal);
   if (!replayWorktree) {
+    const notes2 = [
+      `Replay sandbox creation failed. Original patch preserved at ${originalPatchArtifactPath}.`
+    ];
+    const conflictArtifactPath = await writeConflictBundle({
+      mainCwd,
+      originalPatchArtifactPath,
+      changedFiles: changedFilesSummary ? changedFilesSummary.split(", ").map((item) => item.replace(/ \(\+\d+ more\)$/, "")) : [],
+      notes: notes2,
+      summary: changedFilesSummary ? `Failed to replay the isolated worktree diff because no git replay sandbox could be created. Files involved: ${changedFilesSummary}.` : "Failed to replay the isolated worktree diff because no git replay sandbox could be created."
+    });
     return {
       toolResults: [
         {
@@ -12855,16 +13051,16 @@ async function replayPatchOnLatestWorkspace(mainCwd, sourceWorktreePath, origina
           success: false,
           summary: changedFilesSummary ? `Failed to replay the isolated worktree diff because no git replay sandbox could be created. Files involved: ${changedFilesSummary}.` : "Failed to replay the isolated worktree diff because no git replay sandbox could be created.",
           artifacts: [
-            originalPatchArtifactPath
+            originalPatchArtifactPath,
+            conflictArtifactPath
           ]
         }
       ],
       artifacts: [
-        originalPatchArtifactPath
-      ],
-      notes: [
-        `Replay sandbox creation failed. Original patch preserved at ${originalPatchArtifactPath}.`
+        originalPatchArtifactPath,
+        conflictArtifactPath
       ],
+      notes: notes2,
       integrationFailed: true
     };
   }
@@ -12887,16 +13083,34 @@ async function replayPatchOnLatestWorkspace(mainCwd, sourceWorktreePath, origina
     if (replayApplyResult.code !== 0) {
       const textualReplay = await attemptTextualReplayMerge(mainCwd, replayWorktree.worktreePath, sourceWorktreePath, changedFiles, signal);
       if (!textualReplay.success) {
+        const failureSummary = changedFilesSummary ? `Failed to replay the isolated worktree diff onto the latest workspace snapshot. Files involved: ${changedFilesSummary}.` : "Failed to replay the isolated worktree diff onto the latest workspace snapshot.";
+        const failureNotes = [
+          ...notes,
+          textualReplay.note,
+          `Replay failed in the retry sandbox. Original patch preserved at ${originalPatchArtifactPath}.`
+        ];
+        const conflictArtifactPath = await writeConflictBundle({
+          mainCwd,
+          originalPatchArtifactPath,
+          changedFiles,
+          notes: failureNotes,
+          summary: failureSummary,
+          directApplyStdout: replayApplyResult.stdout,
+          directApplyStderr: replayApplyResult.stderr,
+          replayStdout: textualReplay.stdout,
+          replayStderr: textualReplay.stderr
+        });
+        artifacts.add(conflictArtifactPath);
         toolResults.push({
           toolId: "file.patch",
           success: false,
-          summary: changedFilesSummary ? `Failed to replay the isolated worktree diff onto the latest workspace snapshot. Files involved: ${changedFilesSummary}.` : "Failed to replay the isolated worktree diff onto the latest workspace snapshot.",
+          summary: failureSummary,
           stdout: replayApplyResult.stdout || textualReplay.stdout,
           stderr: replayApplyResult.stderr || textualReplay.stderr,
           artifacts: Array.from(artifacts)
         });
         notes.push(textualReplay.note);
-        notes.push(`Replay failed in the retry sandbox. Original patch preserved at ${originalPatchArtifactPath}.`);
+        notes.push(`Replay failed in the retry sandbox. Original patch preserved at ${originalPatchArtifactPath}. Conflict bundle saved to ${conflictArtifactPath}.`);
         return {
           toolResults,
           artifacts: Array.from(artifacts),
@@ -12948,15 +13162,31 @@ async function replayPatchOnLatestWorkspace(mainCwd, sourceWorktreePath, origina
       replayWorktree.patchArtifactPath
     ], signal);
     if (replayCheckResult.code !== 0) {
+      const failureSummary = changedFilesSummary ? `Replayed patch still does not apply cleanly to the latest main workspace. Files involved: ${changedFilesSummary}.` : "Replayed patch still does not apply cleanly to the latest main workspace.";
+      const failureNotes = [
+        ...notes,
+        `Replay generated a refreshed patch, but it still does not apply cleanly. Refreshed patch preserved at ${replayWorktree.patchArtifactPath}.`
+      ];
+      const conflictArtifactPath = await writeConflictBundle({
+        mainCwd,
+        originalPatchArtifactPath,
+        changedFiles,
+        notes: failureNotes,
+        summary: failureSummary,
+        replayStdout: replayCheckResult.stdout,
+        replayStderr: replayCheckResult.stderr,
+        refreshedPatchArtifactPath: replayWorktree.patchArtifactPath
+      });
+      artifacts.add(conflictArtifactPath);
       toolResults.push({
         toolId: "file.patch",
         success: false,
-        summary: changedFilesSummary ? `Replayed patch still does not apply cleanly to the latest main workspace. Files involved: ${changedFilesSummary}.` : "Replayed patch still does not apply cleanly to the latest main workspace.",
+        summary: failureSummary,
         stdout: replayCheckResult.stdout,
         stderr: replayCheckResult.stderr,
         artifacts: Array.from(artifacts)
       });
-      notes.push(`Replay generated a refreshed patch, but it still does not apply cleanly. Refreshed patch preserved at ${replayWorktree.patchArtifactPath}.`);
+      notes.push(`Replay generated a refreshed patch, but it still does not apply cleanly. Refreshed patch preserved at ${replayWorktree.patchArtifactPath}. Conflict bundle saved to ${conflictArtifactPath}.`);
       return {
         toolResults,
         artifacts: Array.from(artifacts),
@@ -12972,15 +13202,31 @@ async function replayPatchOnLatestWorkspace(mainCwd, sourceWorktreePath, origina
       replayWorktree.patchArtifactPath
     ], signal);
     if (replayMainApplyResult.code !== 0) {
+      const failureSummary = changedFilesSummary ? `Failed to apply the refreshed replay patch back to the main workspace. Files involved: ${changedFilesSummary}.` : "Failed to apply the refreshed replay patch back to the main workspace.";
+      const failureNotes = [
+        ...notes,
+        `Replay patch could not be applied back to the main workspace. Refreshed patch preserved at ${replayWorktree.patchArtifactPath}.`
+      ];
+      const conflictArtifactPath = await writeConflictBundle({
+        mainCwd,
+        originalPatchArtifactPath,
+        changedFiles,
+        notes: failureNotes,
+        summary: failureSummary,
+        replayStdout: replayMainApplyResult.stdout,
+        replayStderr: replayMainApplyResult.stderr,
+        refreshedPatchArtifactPath: replayWorktree.patchArtifactPath
+      });
+      artifacts.add(conflictArtifactPath);
       toolResults.push({
         toolId: "file.patch",
         success: false,
-        summary: changedFilesSummary ? `Failed to apply the refreshed replay patch back to the main workspace. Files involved: ${changedFilesSummary}.` : "Failed to apply the refreshed replay patch back to the main workspace.",
+        summary: failureSummary,
         stdout: replayMainApplyResult.stdout,
         stderr: replayMainApplyResult.stderr,
         artifacts: Array.from(artifacts)
       });
-      notes.push(`Replay patch could not be applied back to the main workspace. Refreshed patch preserved at ${replayWorktree.patchArtifactPath}.`);
+      notes.push(`Replay patch could not be applied back to the main workspace. Refreshed patch preserved at ${replayWorktree.patchArtifactPath}. Conflict bundle saved to ${conflictArtifactPath}.`);
       return {
         toolResults,
         artifacts: Array.from(artifacts),
@@ -13574,6 +13820,11 @@ var ExecutionOrchestrator = class {
     }
     const scaffoldResult = await this.safeRunTool("scaffold.generate", scaffoldInput, {
       cwd: request.cwd,
+      ...config ? {
+        approvalMode: config.approvalMode,
+        sandboxMode: config.sandboxMode,
+        agentRole: task.agentRole
+      } : {},
       ...options.signal ? {
         signal: options.signal
       } : {}
@@ -13608,6 +13859,11 @@ var ExecutionOrchestrator = class {
     }
     const repoIndexResult = await this.safeRunTool("repo.index", {}, {
       cwd: request.cwd,
+      ...config ? {
+        approvalMode: config.approvalMode,
+        sandboxMode: config.sandboxMode,
+        agentRole: task.agentRole
+      } : {},
       ...options.signal ? {
         signal: options.signal
       } : {}
@@ -13727,7 +13983,9 @@ var ExecutionOrchestrator = class {
   async executeRepoAnalysisTask(sessionId, task, request, emitProgress, signal) {
     const context = { cwd: request.cwd };
     const toolResults = [];
-    const probes = [
+    const probes = request.workspaceState === "empty" ? [
+      { toolId: "repo.index", input: {} }
+    ] : [
       { toolId: "repo.index", input: {} },
       { toolId: "git.status", input: {} },
       { toolId: "file.read", input: { path: "package.json" } },
@@ -14420,7 +14678,6 @@ function createModelsCommand() {
 }
 
 // src/commands/plan.ts
-var import_promises12 = require("node:fs/promises");
 var import_node_process7 = __toESM(require("node:process"), 1);
 
 // ../planner/dist/planner.js
@@ -14429,6 +14686,9 @@ function normalizeGoal(goal) {
 }
 function inferProjectShape(goal) {
   const lower = goal.toLowerCase();
+  if (lower.includes("landing page") || lower.includes("homepage") || lower.includes("marketing page") || lower.includes("storefront") || lower.includes("restaurant website") || lower.includes("restaurant site") || lower.includes("static site")) {
+    return "static-site";
+  }
   if (lower.includes("agent") || lower.includes("cli") || lower.includes("terminal")) {
     return "cli-agent";
   }
@@ -14453,7 +14713,7 @@ function buildTask(id, title, description, agentRole, type, dependsOn, acceptanc
   };
 }
 function foundationMilestone(shape) {
-  const objective = shape === "cli-agent" ? "Establish the CLI monorepo, shared contracts, and first operational commands." : "Establish the application structure, baseline tooling, and implementation scaffolding.";
+  const objective = shape === "cli-agent" ? "Establish the CLI monorepo, shared contracts, and first operational commands." : shape === "static-site" ? "Establish the site structure, initial content direction, and deterministic scaffold." : "Establish the application structure, baseline tooling, and implementation scaffolding.";
   return {
     id: "m1-foundation",
     title: "Foundation",
@@ -14498,6 +14758,27 @@ function foundationMilestone(shape) {
   };
 }
 function implementationMilestone(shape) {
+  if (shape === "static-site") {
+    return {
+      id: "m2-experience",
+      title: "Experience",
+      objective: "Refine the landing-page experience, content, and responsive presentation.",
+      tasks: [
+        buildTask("t4-experience", "Tailor the landing-page experience", "Customize the generated landing page so the layout, copy, and visual direction fit the requested business or venue.", "frontend-specialist", "implementation", [
+          "t3-scaffold"
+        ], [
+          "The page reflects the requested business domain and tone.",
+          "The layout is responsive and visually coherent."
+        ], [
+          "Customized landing page"
+        ], [
+          "index.html",
+          "styles.css",
+          "src/"
+        ], "medium")
+      ]
+    };
+  }
   if (shape === "cli-agent") {
     return {
       id: "m2-runtime",
@@ -14614,6 +14895,8 @@ function verificationMilestone(shape) {
         "t6-runtime",
         "t7-tools",
         "t8-shell"
+      ] : shape === "static-site" ? [
+        "t4-experience"
       ] : [
         "t5-backend",
         "t6-frontend"
@@ -14656,6 +14939,9 @@ function deriveAssumptions(shape, request) {
   if (shape === "full-stack-app") {
     assumptions.push("The product needs a frontend, backend, and persistence layer.");
   }
+  if (shape === "static-site") {
+    assumptions.push("The initial deliverable can ship as a static site without backend infrastructure.");
+  }
   if (request.constraints.length > 0) {
     assumptions.push(`The plan must honor ${request.constraints.length} explicit user constraints.`);
   }
@@ -14676,6 +14962,13 @@ function deriveOpenQuestions(shape) {
       "What external services or APIs must be integrated?"
     ];
   }
+  if (shape === "static-site") {
+    return [
+      "What brand voice and visual direction should the page follow?",
+      "Which sections are required on the first version of the landing page?",
+      "What primary call to action should the page drive?"
+    ];
+  }
   return [
     "Which stack and deployment target should be preferred?",
     "What user journeys count as the minimum viable release?"
@@ -14689,6 +14982,9 @@ function deriveVerificationChecklist(shape) {
   if (shape === "cli-agent") {
     checklist.push("CLI commands render correctly and save plan artifacts.");
     checklist.push("Plan contracts remain schema-valid across packages.");
+  } else if (shape === "static-site") {
+    checklist.push("The page renders cleanly on desktop and mobile-sized viewports.");
+    checklist.push("Primary calls to action and anchor navigation work.");
   } else if (shape === "full-stack-app") {
     checklist.push("The build, lint, and test flows pass.");
     checklist.push("Primary UI and API paths are smoke-tested.");
@@ -14702,6 +14998,9 @@ function buildSummary(shape, goal) {
   if (shape === "full-stack-app") {
     return `Deliver the full-stack implementation for "${goal}" through staged architecture, implementation, and verification milestones.`;
   }
+  if (shape === "static-site") {
+    return `Deliver a polished landing-page implementation for "${goal}" through scaffold, refinement, and verification milestones.`;
+  }
   return `Deliver "${goal}" through structured analysis, implementation, and verification milestones.`;
 }
 function createPlan(input) {
@@ -14734,12 +15033,176 @@ function createPlan(input) {
   });
 }
 
-// src/commands/plan.ts
+// src/workspace.ts
+var import_promises12 = require("node:fs/promises");
+var import_node_path12 = __toESM(require("node:path"), 1);
+var PROJECT_MARKERS = /* @__PURE__ */ new Set([
+  ".git",
+  "package.json",
+  "tsconfig.json",
+  "pnpm-workspace.yaml",
+  "turbo.json",
+  "vite.config.ts",
+  "vite.config.js",
+  "next.config.ts",
+  "next.config.js",
+  "src",
+  "app",
+  "pages",
+  "prisma",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod"
+]);
+var GREENFIELD_KEYWORDS = [
+  "build",
+  "create",
+  "make",
+  "scaffold",
+  "generate",
+  "new app",
+  "new project",
+  "landing page",
+  "homepage",
+  "marketing page",
+  "storefront",
+  "website"
+];
+var EXISTING_REPO_PATTERNS = [
+  /\bthis repo\b/i,
+  /\bthis repository\b/i,
+  /\bthis project\b/i,
+  /\bthis codebase\b/i,
+  /\bcurrent repo\b/i,
+  /\bcurrent project\b/i,
+  /\bexisting repo\b/i,
+  /\bexisting project\b/i,
+  /\bin this repo\b/i,
+  /\bin this project\b/i
+];
+var WORKSPACE_NAME_STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "app",
+  "application",
+  "build",
+  "create",
+  "for",
+  "generate",
+  "make",
+  "new",
+  "page",
+  "please",
+  "project",
+  "scaffold",
+  "site",
+  "that",
+  "the",
+  "to",
+  "website",
+  "with"
+]);
+async function readEntries(cwd) {
+  try {
+    return await (0, import_promises12.readdir)(cwd);
+  } catch {
+    return [];
+  }
+}
+async function readMeaningfulEntries(cwd) {
+  const entries = await readEntries(cwd);
+  return entries.filter((entry) => entry !== ".kimbho" && !entry.startsWith("."));
+}
+async function isProjectWorkspace(cwd) {
+  const entries = await readEntries(cwd);
+  return entries.some((entry) => PROJECT_MARKERS.has(entry));
+}
+function isGreenfieldGoal(goal) {
+  const normalized = goal.trim().toLowerCase();
+  if (!normalized || EXISTING_REPO_PATTERNS.some((pattern) => pattern.test(normalized))) {
+    return false;
+  }
+  return GREENFIELD_KEYWORDS.some((keyword) => normalized.includes(keyword));
+}
+function sanitizeWorkspaceName(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+}
+function inferWorkspaceName(goal) {
+  const normalized = goal.trim().toLowerCase();
+  const trailingContext = normalized.split(/\bfor\b/).at(-1)?.trim() ?? normalized;
+  const contextWords = trailingContext.split(/\s+/).map((word) => sanitizeWorkspaceName(word)).filter((word) => word.length > 0 && !WORKSPACE_NAME_STOP_WORDS.has(word));
+  const goalWords = normalized.split(/\s+/).map((word) => sanitizeWorkspaceName(word)).filter((word) => word.length > 0 && !WORKSPACE_NAME_STOP_WORDS.has(word));
+  const preferred = [
+    ...contextWords,
+    ...goalWords
+  ];
+  const deduped = Array.from(new Set(preferred)).slice(0, 4);
+  const candidate = sanitizeWorkspaceName(deduped.join("-"));
+  return candidate.length > 0 ? candidate : "kimbho-app";
+}
+async function chooseWorkspacePath(baseCwd, workspaceName) {
+  const basePath = import_node_path12.default.join(baseCwd, workspaceName);
+  let attempt = 0;
+  while (attempt < 50) {
+    const suffix = attempt === 0 ? "" : `-${attempt + 1}`;
+    const candidatePath = `${basePath}${suffix}`;
+    const entries = await readMeaningfulEntries(candidatePath);
+    if (entries.length === 0) {
+      return candidatePath;
+    }
+    attempt += 1;
+  }
+  return `${basePath}-${Date.now()}`;
+}
 async function detectWorkspaceState(cwd) {
-  const entries = await (0, import_promises12.readdir)(cwd);
-  const meaningfulEntries = entries.filter((entry) => entry !== ".kimbho" && !entry.startsWith("."));
+  if (await isProjectWorkspace(cwd)) {
+    return "existing";
+  }
+  const meaningfulEntries = await readMeaningfulEntries(cwd);
   return meaningfulEntries.length === 0 ? "empty" : "existing";
 }
+async function inferPlanningWorkspaceState(cwd, goal) {
+  const existingState = await detectWorkspaceState(cwd);
+  if (existingState === "empty" || await isProjectWorkspace(cwd) || !isGreenfieldGoal(goal)) {
+    return existingState;
+  }
+  return "empty";
+}
+async function resolveExecutionWorkspace(cwd, goal) {
+  const workspaceState = await detectWorkspaceState(cwd);
+  if (workspaceState === "empty" || await isProjectWorkspace(cwd) || !isGreenfieldGoal(goal)) {
+    return {
+      cwd,
+      workspaceState,
+      notes: []
+    };
+  }
+  const workspaceName = inferWorkspaceName(goal);
+  const targetCwd = await chooseWorkspacePath(cwd, workspaceName);
+  await (0, import_promises12.mkdir)(targetCwd, { recursive: true });
+  const notes = [
+    `Created workspace ${targetCwd} for this greenfield build because ${cwd} is not a project workspace.`
+  ];
+  let inheritedConfigPath;
+  const sourceConfig = await loadConfig(cwd);
+  const targetConfig = await loadConfig(targetCwd);
+  if (sourceConfig && !targetConfig) {
+    inheritedConfigPath = await saveConfig(sourceConfig, targetCwd);
+    notes.push(`Copied the active Kimbho config into ${targetCwd} so model/provider settings carry over.`);
+  }
+  return {
+    cwd: targetCwd,
+    workspaceState: await detectWorkspaceState(targetCwd),
+    createdWorkspacePath: targetCwd,
+    ...inheritedConfigPath ? {
+      inheritedConfigPath
+    } : {},
+    notes
+  };
+}
+
+// src/commands/plan.ts
 function createPlanCommand() {
   return new Command("plan").description("Generate a structured Kimbho execution plan for the provided goal.").argument("<goal>", "High-level product or engineering goal").option("--stack <stack>", "Preferred stack or preset").option(
     "--constraint <constraint>",
@@ -14752,7 +15215,7 @@ function createPlanCommand() {
       goal,
       mode: "plan",
       cwd,
-      workspaceState: await detectWorkspaceState(cwd),
+      workspaceState: await inferPlanningWorkspaceState(cwd, goal),
       stackPreference: options.stack,
       constraints: options.constraint
     };
@@ -14891,7 +15354,7 @@ function createProvidersCommand() {
 
 // src/commands/review.ts
 var import_promises13 = require("node:fs/promises");
-var import_node_path12 = __toESM(require("node:path"), 1);
+var import_node_path13 = __toESM(require("node:path"), 1);
 var import_node_process9 = __toESM(require("node:process"), 1);
 function summarizeChangedFiles2(diff) {
   const files = /* @__PURE__ */ new Set();
@@ -14975,7 +15438,7 @@ ${diff.stdout}`
       }
     }
     await ensureKimbhoDir(cwd);
-    const artifactPath = import_node_path12.default.join(resolveKimbhoDir(cwd), "logs", `review-${Date.now()}.md`);
+    const artifactPath = import_node_path13.default.join(resolveKimbhoDir(cwd), "logs", `review-${Date.now()}.md`);
     await (0, import_promises13.writeFile)(artifactPath, [
       `# Review`,
       ``,
@@ -15030,7 +15493,7 @@ function parseCount(value) {
   return parsed;
 }
 function createResumeCommand() {
-  return new Command("resume").description("Resume the latest saved Kimbho session snapshot.").option("--json", "Print the latest session as JSON", false).option("--execute", "Continue auto-executing the ready-task frontier", false).option("--max-auto-tasks <count>", "Maximum ready tasks to auto-execute", parseCount, 2).option("--max-agent-steps <count>", "Maximum tool/model steps per autonomous task", parseCount, 8).option("--max-repair-attempts <count>", "Maximum failed verification cycles per autonomous task", parseCount, 2).action(async (options) => {
+  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, 3).option("--max-agent-steps <count>", "Maximum tool/model steps per autonomous task", parseCount, 8).option("--max-repair-attempts <count>", "Maximum failed verification cycles per autonomous task", parseCount, 2).action(async (options) => {
     const cwd = import_node_process10.default.cwd();
     const session = await loadLatestSession(cwd);
     if (!session) {
@@ -15055,13 +15518,7 @@ function createResumeCommand() {
 }
 
 // src/commands/run.ts
-var import_promises14 = require("node:fs/promises");
 var import_node_process11 = __toESM(require("node:process"), 1);
-async function detectWorkspaceState2(cwd) {
-  const entries = await (0, import_promises14.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) {
@@ -15075,7 +15532,7 @@ function createRunCommand() {
     "Explicit execution constraint; can be provided multiple times",
     (value, previous = []) => [...previous, value],
     []
-  ).option("--json", "Print the session snapshot as JSON", false).option("--snapshot-only", "Create the session without auto-executing ready tasks", false).option("--max-auto-tasks <count>", "Maximum ready tasks to auto-execute", parseCount2, 2).option("--max-agent-steps <count>", "Maximum tool/model steps per autonomous task", parseCount2, 8).option("--max-repair-attempts <count>", "Maximum failed verification cycles per autonomous task", parseCount2, 2).action(async (goal, options) => {
+  ).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, 3).option("--max-agent-steps <count>", "Maximum tool/model steps per autonomous task", parseCount2, 8).option("--max-repair-attempts <count>", "Maximum failed verification cycles per autonomous task", parseCount2, 2).action(async (goal, options) => {
     const cwd = import_node_process11.default.cwd();
     const orchestrator = new ExecutionOrchestrator();
     let request;
@@ -15087,22 +15544,26 @@ function createRunCommand() {
       return;
     }
     if (goal) {
+      const workspace = await resolveExecutionWorkspace(cwd, goal);
       request = {
         goal,
         mode: "run",
-        cwd,
-        workspaceState: await detectWorkspaceState2(cwd),
+        cwd: workspace.cwd,
+        workspaceState: workspace.workspaceState,
         stackPreference: options.stack,
         constraints: options.constraint
       };
       plan = createPlan(request);
-      planPath = await savePlan(plan, cwd);
+      planPath = await savePlan(plan, workspace.cwd);
+      for (const note of workspace.notes) {
+        console.log(note);
+      }
     } else {
       request = {
         goal: plan.goal,
         mode: "run",
         cwd,
-        workspaceState: await detectWorkspaceState2(cwd),
+        workspaceState: plan.repoStrategy.mode === "greenfield" ? "empty" : "existing",
         stackPreference: options.stack,
         constraints: options.constraint
       };
@@ -15114,7 +15575,7 @@ function createRunCommand() {
       maxAgentSteps: options.maxAgentSteps,
       maxRepairAttempts: options.maxRepairAttempts
     });
-    const sessionPath = await saveSession(snapshot, cwd);
+    const sessionPath = await saveSession(snapshot, request.cwd);
     if (options.json) {
       console.log(
         renderJson({
@@ -15133,6 +15594,9 @@ function createRunCommand() {
       console.log(`Saved plan: ${planPath}`);
     }
     console.log(`Saved session: ${sessionPath}`);
+    if (request.cwd !== cwd) {
+      console.log(`Continue in: cd ${request.cwd}`);
+    }
   });
 }
 
@@ -15193,8 +15657,7 @@ function createProgram(onOpenShell) {
 }
 
 // src/shell.ts
-var import_promises15 = require("node:fs/promises");
-var import_promises16 = require("node:readline/promises");
+var import_promises14 = require("node:readline/promises");
 var import_node_process12 = __toESM(require("node:process"), 1);
 var AMBER = "\x1B[38;5;214m";
 var CYAN = "\x1B[38;5;45m";
@@ -15241,7 +15704,7 @@ var BRAIN_ROLES = [
   "fast"
 ];
 var MAX_CHAT_MESSAGES = 12;
-var DEFAULT_MAX_AUTO_TASKS = 2;
+var DEFAULT_MAX_AUTO_TASKS = 3;
 var DEFAULT_MAX_AGENT_STEPS = 8;
 var DEFAULT_MAX_REPAIR_ATTEMPTS2 = 2;
 var EXECUTION_PREFIXES = [
@@ -15524,11 +15987,6 @@ function printHeader(cwd, state) {
   console.log(renderHelp());
   console.log("");
 }
-async function detectWorkspaceState3(cwd) {
-  const entries = await (0, import_promises15.readdir)(cwd);
-  const meaningfulEntries = entries.filter((entry) => entry !== ".kimbho" && !entry.startsWith("."));
-  return meaningfulEntries.length === 0 ? "empty" : "existing";
-}
 function inferPromptIntent(input) {
   const normalized = input.trim().toLowerCase();
   if (!normalized) {
@@ -15952,15 +16410,16 @@ async function handleChatPrompt(cwd, prompt, runtime) {
 }
 async function runGoalExecution(cwd, goal, runtime) {
   const orchestrator = new ExecutionOrchestrator();
+  const workspace = await resolveExecutionWorkspace(cwd, goal);
   const request = {
     goal,
     mode: "run",
-    cwd,
-    workspaceState: await detectWorkspaceState3(cwd),
+    cwd: workspace.cwd,
+    workspaceState: workspace.workspaceState,
     constraints: []
   };
   const plan = createPlan(request);
-  const planPath = await savePlan(plan, cwd);
+  const planPath = await savePlan(plan, request.cwd);
   const envelope = orchestrator.buildEnvelope(request, plan);
   const initialSnapshot = orchestrator.createSessionSnapshot(envelope);
   const startedAt = Date.now();
@@ -15980,8 +16439,8 @@ async function runGoalExecution(cwd, goal, runtime) {
     label: goal
   };
   console.log(color(DIM, `Working on: ${goal}`));
-  if (cwd === import_node_process12.default.env.HOME) {
-    console.log(color(DIM, `warning: current directory is ${cwd}; created files will land here unless you cd into a project folder first.`));
+  for (const note of workspace.notes) {
+    console.log(color(DIM, note));
   }
   console.log(renderShellPlanPreview(plan).join("\n"));
   console.log(renderRunStartCard(liveBoard));
@@ -16019,11 +16478,13 @@ async function runGoalExecution(cwd, goal, runtime) {
   } finally {
     runtime.activeExecution = null;
   }
-  const sessionPath = await saveSession(snapshot, cwd);
+  const sessionPath = await saveSession(snapshot, request.cwd);
+  runtime.currentCwd = request.cwd;
   console.log("");
   console.log(color(DIM, `elapsed: ${((Date.now() - startedAt) / 1e3).toFixed(1)}s`));
   console.log(color(DIM, renderExecutionTelemetry(telemetry, startedAt)));
   console.log(renderShellSessionSummary(snapshot, planPath, sessionPath));
+  return request.cwd;
 }
 async function resumeGoalExecution(cwd, runtime) {
   const session = await loadLatestSession(cwd);
@@ -16099,7 +16560,7 @@ async function createPlanOnly(cwd, goal) {
     goal,
     mode: "plan",
     cwd,
-    workspaceState: await detectWorkspaceState3(cwd),
+    workspaceState: await inferPlanningWorkspaceState(cwd, goal),
     constraints: []
   };
   const plan = createPlan(request);
@@ -16543,18 +17004,18 @@ function toExternalCommandTokens(input, state) {
 async function handleShellCommand(cwd, input, state, runtime, execute) {
   const trimmed = input.trim();
   if (!trimmed) {
-    return;
+    return cwd;
   }
   if (trimmed === "/exit" || trimmed === "exit" || trimmed === "quit" || trimmed === "/quit") {
     throw new Error("__kimbho_exit__");
   }
   if (trimmed === "/help" || trimmed === "help" || trimmed === "?") {
     console.log(renderHelp());
-    return;
+    return cwd;
   }
   if (trimmed === "/status" || trimmed === "status") {
     console.log(renderStartupCard(cwd, state));
-    return;
+    return cwd;
   }
   if (trimmed === "/clear" || trimmed === "clear") {
     if (import_node_process12.default.stdout.isTTY) {
@@ -16562,28 +17023,28 @@ async function handleShellCommand(cwd, input, state, runtime, execute) {
     }
     const nextState = await getShellSessionState(cwd, runtime.focusRole);
     printHeader(cwd, nextState);
-    return;
+    return cwd;
   }
   const { tokens, head } = normalizeInputTokens(trimmed);
   const firstToken = tokens[0];
   const isSlashCommand = firstToken?.startsWith("/") ?? false;
   if (!head) {
-    return;
+    return cwd;
   }
   if (!firstToken?.startsWith("/") && !TOP_LEVEL_COMMANDS.has(head) && !head.startsWith("-")) {
     const intent = inferPromptIntent(trimmed);
     if (intent === "run") {
-      await runGoalExecution(cwd, trimmed, runtime);
+      const nextCwd = await runGoalExecution(cwd, trimmed, runtime);
       clearAllConversations(runtime);
       runtime.lastModels = null;
-      return;
+      return nextCwd;
     }
     if (intent === "plan") {
       await createPlanOnly(cwd, normalizePlanPrompt(trimmed));
-      return;
+      return cwd;
     }
     await handleChatPrompt(cwd, trimmed, runtime);
-    return;
+    return cwd;
   }
   if (head === "provider" || head === "providers") {
     const subcommand = tokens[1];
@@ -16593,7 +17054,7 @@ async function handleShellCommand(cwd, input, state, runtime, execute) {
         "providers",
         ...tokens.slice(1)
       ], runtime);
-      return;
+      return cwd;
     }
   }
   if (head === "brain" || head === "brains") {
@@ -16605,12 +17066,12 @@ async function handleShellCommand(cwd, input, state, runtime, execute) {
         "brain",
         ...tokens.slice(1)
       ], runtime);
-      return;
+      return cwd;
     }
   }
   if (head === "model") {
     await printBrainAssignments(cwd);
-    return;
+    return cwd;
   }
   if (head === "ask" || head === "chat") {
     const prompt = tokens.slice(1).join(" ").trim();
@@ -16618,19 +17079,19 @@ async function handleShellCommand(cwd, input, state, runtime, execute) {
       throw new Error(`Usage: /${head} <prompt>`);
     }
     await handleChatPrompt(cwd, prompt, runtime);
-    return;
+    return cwd;
   }
   if (head === "reset-chat") {
     clearConversation(runtime, runtime.focusRole);
     console.log(`Cleared ${runtime.focusRole} conversation history.`);
-    return;
+    return cwd;
   }
   if (head === "models") {
     await handleModelsCommand(cwd, [
       "models",
       ...tokens.slice(1)
     ], runtime);
-    return;
+    return cwd;
   }
   if (head === "use-model") {
     const modelId = tokens.slice(1).join(" ").trim();
@@ -16638,50 +17099,51 @@ async function handleShellCommand(cwd, input, state, runtime, execute) {
       throw new Error("Usage: /use-model <model-id>");
     }
     await handleModelSelection(cwd, modelId, runtime);
-    return;
+    return cwd;
   }
   if (head === "select") {
     await handleSelectCommand(cwd, [
       "select",
       ...tokens.slice(1)
     ], runtime);
-    return;
+    return cwd;
   }
   if (head === "run" || head === "new" || head === "scaffold") {
     const goal = head === "run" ? tokens.slice(1).join(" ").trim() : head === "new" ? tokens.slice(1).join(" ").trim() : `scaffold ${tokens.slice(1).join(" ").trim()}`.trim();
     if (!goal) {
       throw new Error(`Usage: /${head} <goal>`);
     }
-    await runGoalExecution(cwd, goal, runtime);
+    const nextCwd = await runGoalExecution(cwd, goal, runtime);
     clearAllConversations(runtime);
     runtime.lastModels = null;
-    return;
+    return nextCwd;
   }
   if (head === "plan") {
     if (!isSlashCommand) {
       await createPlanOnly(cwd, normalizePlanPrompt(trimmed));
-      return;
+      return cwd;
     }
     const goal = tokens.slice(1).join(" ").trim();
     if (!goal) {
       await printLatestPlanSummary(cwd);
-      return;
+      return cwd;
     }
     await createPlanOnly(cwd, goal);
-    return;
+    return cwd;
   }
   if (head === "resume") {
     await resumeGoalExecution(cwd, runtime);
-    return;
+    return cwd;
   }
   const externalTokens = toExternalCommandTokens(trimmed, state);
   if (externalTokens.length === 0) {
-    return;
+    return cwd;
   }
   await execute(externalTokens);
+  return cwd;
 }
 async function runInteractiveShell(options) {
-  const readline = (0, import_promises16.createInterface)({
+  const readline = (0, import_promises14.createInterface)({
     input: import_node_process12.default.stdin,
     output: import_node_process12.default.stdout,
     terminal: Boolean(import_node_process12.default.stdin.isTTY && import_node_process12.default.stdout.isTTY)
@@ -16689,6 +17151,7 @@ async function runInteractiveShell(options) {
   const runtime = {
     focusRole: "coder",
     lastModels: null,
+    currentCwd: options.cwd,
     activeExecution: null,
     conversations: {
       planner: [],
@@ -16697,6 +17160,7 @@ async function runInteractiveShell(options) {
       fast: []
     }
   };
+  let currentCwd = options.cwd;
   let closed = false;
   readline.on("SIGINT", () => {
     if (runtime.activeExecution) {
@@ -16708,18 +17172,19 @@ async function runInteractiveShell(options) {
     closed = true;
     readline.close();
   });
-  let state = await getShellSessionState(options.cwd, runtime.focusRole);
-  printHeader(options.cwd, state);
+  let state = await getShellSessionState(currentCwd, runtime.focusRole);
+  printHeader(currentCwd, state);
   while (!closed) {
     let line;
     try {
-      state = await getShellSessionState(options.cwd, runtime.focusRole);
+      state = await getShellSessionState(currentCwd, runtime.focusRole);
       line = await readline.question(formatPrompt(state));
     } catch {
       break;
     }
     try {
-      await handleShellCommand(options.cwd, line, state, runtime, options.execute);
+      currentCwd = await handleShellCommand(currentCwd, line, state, runtime, options.execute);
+      runtime.currentCwd = currentCwd;
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (message === "__kimbho_exit__") {