autohand-cli 0.7.4 → 0.7.6

package/dist/index.js

@@ -2,9 +2,10 @@
 import {
   PermissionManager
 } from "./chunk-YMP7AGNT.js";
+import "./chunk-27ISZOFA.js";
 import {
   SessionManager
-} from "./chunk-2FLBGPE3.js";
+} from "./chunk-VO3JKFUH.js";
 import {
   MemoryManager
 } from "./chunk-4L5WYXHN.js";
@@ -28,7 +29,9 @@ import {
 import {
   metadata as metadata26
 } from "./chunk-CXZEPTRI.js";
-import "./chunk-27ISZOFA.js";
+import {
+  metadata as metadata27
+} from "./chunk-723DZKBU.js";
 import {
   metadata as metadata15
 } from "./chunk-2NUX2RAI.js";
@@ -39,9 +42,11 @@ import {
   metadata as metadata17
 } from "./chunk-OC5YDNFC.js";
 import {
-  metadata as metadata18,
+  metadata as metadata18
+} from "./chunk-4KZCGK7D.js";
+import {
   package_default
-} from "./chunk-546JQ3ND.js";
+} from "./chunk-5MCDN53U.js";
 import {
   metadata as metadata19
 } from "./chunk-2FSQPRPJ.js";
@@ -93,12 +98,6 @@ import {
   applyFormatter,
   metadata as metadata14
 } from "./chunk-XDVG3NM4.js";
-import {
-  AUTOHAND_FILES,
-  AUTOHAND_HOME,
-  AUTOHAND_PATHS,
-  PROJECT_DIR_NAME
-} from "./chunk-FUEL6BK7.js";
 import {
   metadata
 } from "./chunk-KZ7VMQTC.js";
@@ -114,7 +113,13 @@ import {
 } from "./chunk-Z3Q2AFDS.js";
 import {
   metadata as metadata5
-} from "./chunk-55DQY6B5.js";
+} from "./chunk-R5KNHJ27.js";
+import {
+  AUTOHAND_FILES,
+  AUTOHAND_HOME,
+  AUTOHAND_PATHS,
+  PROJECT_DIR_NAME
+} from "./chunk-FUEL6BK7.js";
 import {
   metadata as metadata6
 } from "./chunk-QJ53OSGF.js";
@@ -122,8 +127,7 @@ import {
 // src/index.ts
 import "dotenv/config";
 import { Command } from "commander";
-import chalk16 from "chalk";
-import enquirer4 from "enquirer";
+import chalk17 from "chalk";
 import { execSync as execSync3 } from "child_process";
 
 // src/startup/checks.ts
@@ -228,21 +232,67 @@ async function checkWorkspaceWritable(workspaceRoot) {
     };
   }
 }
-function checkGitRepo(workspaceRoot) {
+function isEmptyDirectory(dir) {
+  try {
+    const entries = fs.readdirSync(dir);
+    const significantEntries = entries.filter((e) => !e.startsWith(".") || e === ".git");
+    return significantEntries.length === 0;
+  } catch {
+    return false;
+  }
+}
+function getGitBranch(workspaceRoot) {
   try {
     const result = spawnSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
       cwd: workspaceRoot,
       encoding: "utf8",
       timeout: 5e3
     });
-    if (result.status === 0) {
-      return {
-        isGitRepo: true,
-        branch: result.stdout.trim()
-      };
+    if (result.status === 0 && result.stdout.trim()) {
+      return result.stdout.trim();
+    }
+  } catch {
+  }
+  try {
+    const result = spawnSync("git", ["symbolic-ref", "--short", "HEAD"], {
+      cwd: workspaceRoot,
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    if (result.status === 0 && result.stdout.trim()) {
+      return result.stdout.trim();
     }
   } catch {
   }
+  return void 0;
+}
+function checkGitRepo(workspaceRoot) {
+  const gitDirExists = fs.existsSync(`${workspaceRoot}/.git`);
+  if (gitDirExists) {
+    const branch = getGitBranch(workspaceRoot);
+    return {
+      isGitRepo: true,
+      branch
+    };
+  }
+  if (isEmptyDirectory(workspaceRoot)) {
+    try {
+      const initResult = spawnSync("git", ["init"], {
+        cwd: workspaceRoot,
+        encoding: "utf8",
+        timeout: 5e3
+      });
+      if (initResult.status === 0) {
+        const branch = getGitBranch(workspaceRoot) || "main";
+        return {
+          isGitRepo: true,
+          branch,
+          initialized: true
+        };
+      }
+    } catch {
+    }
+  }
   return { isGitRepo: false };
 }
 function getPackageManagerHint() {
@@ -285,6 +335,7 @@ async function runStartupChecks(workspaceRoot) {
       writable: workspaceCheck.writable,
       isGitRepo: gitCheck.isGitRepo,
       branch: gitCheck.branch,
+      initialized: gitCheck.initialized,
       error: workspaceCheck.error
     },
     allRequiredMet,
@@ -294,6 +345,10 @@ async function runStartupChecks(workspaceRoot) {
 function printStartupCheckResults(results, verbose = false) {
   const missingRequired = results.tools.filter((t) => t.required && !t.installed);
   const missingOptional = results.tools.filter((t) => !t.required && !t.installed);
+  if (results.workspace.initialized) {
+    console.log(chalk.green("\u2713 Initialized git repository"));
+    console.log();
+  }
   if (missingRequired.length === 0 && !verbose) {
     return;
   }
@@ -1778,6 +1833,26 @@ var OpenRouterClient = class {
         payload.tool_choice = request.toolChoice;
       }
     }
+    const model = (request.model ?? this.defaultModel).toLowerCase();
+    if (request.thinkingLevel && request.thinkingLevel !== "normal") {
+      if (model.includes("o1") || model.includes("o3")) {
+        if (request.thinkingLevel === "extended") {
+          payload.reasoning_effort = "high";
+        } else if (request.thinkingLevel === "none") {
+          payload.reasoning_effort = "low";
+        }
+      }
+      if (model.includes("claude") && request.thinkingLevel === "extended") {
+        payload.provider = {
+          anthropic: {
+            thinking: {
+              type: "enabled",
+              budget_tokens: 1e4
+            }
+          }
+        };
+      }
+    }
     const headers = {
       "Content-Type": "application/json",
       "HTTP-Referer": "https://github.com/autohandai/code-cli",
@@ -2197,14 +2272,13 @@ var ProviderFactory = class {
 };
 
 // src/core/agent.ts
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 import fs19 from "fs-extra";
 import path18 from "path";
 import { randomUUID } from "crypto";
 import { spawnSync as spawnSync5 } from "child_process";
 import ora from "ora";
-import enquirer3 from "enquirer";
-import readline4 from "readline";
+import enquirer4 from "enquirer";
 
 // src/ui/inputPrompt.ts
 import chalk5 from "chalk";
@@ -2296,7 +2370,7 @@ var MentionPreview = class {
     this.disposed = false;
     this.lastSuggestions = [];
     const input = rl.input;
-    readline.emitKeypressEvents(input, rl);
+    safeEmitKeypressEvents(input);
     this.statusLine = statusLine ? chalk3.gray(statusLine) : void 0;
     this.keypressHandler = this.handleKeypress.bind(this);
     input.prependListener("keypress", this.keypressHandler);
@@ -2664,6 +2738,13 @@ function drawInputBox(prompt, width) {
 // src/ui/inputPrompt.ts
 var NEWLINE_MARKER = " \u21B5 ";
 var MAX_NEWLINES = 2;
+var instrumentedStreams = /* @__PURE__ */ new WeakSet();
+function safeEmitKeypressEvents(stream) {
+  if (!instrumentedStreams.has(stream)) {
+    readline2.emitKeypressEvents(stream);
+    instrumentedStreams.add(stream);
+  }
+}
 function countNewlineMarkers(text) {
   return (text.match(new RegExp(NEWLINE_MARKER, "g")) || []).length;
 }
@@ -2677,6 +2758,7 @@ async function readInstruction(files, slashCommands, statusLine, io = {}, onImag
   }, 1e4);
   try {
     while (true) {
+      await new Promise((resolve) => process.nextTick(resolve));
       const result = await promptOnce({
         files,
         slashCommands,
@@ -2695,8 +2777,11 @@ async function readInstruction(files, slashCommands, statusLine, io = {}, onImag
   }
 }
 function createReadline(stdInput, stdOutput) {
-  if (stdInput.isPaused && stdInput.isPaused()) {
+  stdOutput.write("\r");
+  safeEmitKeypressEvents(stdInput);
+  try {
     stdInput.resume();
+  } catch {
   }
   const rl = readline2.createInterface({
     input: stdInput,
@@ -2893,6 +2978,9 @@ ${chalk5.gray("Press Ctrl+C again to exit.")}
     input.on("keypress", handleKeypress);
     rl.setPrompt(`${chalk5.gray("\u203A")} `);
     rl.prompt(true);
+    process.nextTick(() => {
+      stdOutput.write(`\r${chalk5.gray("\u203A")} `);
+    });
     rl.on("line", (value) => {
       let finalValue = convertNewlineMarkersToNewlines(value).trim();
       finalValue = processImagesInText(finalValue);
@@ -3964,7 +4052,8 @@ var SLASH_COMMANDS = [
   installMetadata,
   metadata24,
   metadata25,
-  metadata26
+  metadata26,
+  metadata27
 ];
 
 // src/core/conversationManager.ts
@@ -8534,7 +8623,7 @@ var SlashCommandHandler = class {
           return feedback(this.ctx);
         }
         case "/resume": {
-          const { resume } = await import("./resume-2NERFSTD.js");
+          const { resume } = await import("./resume-CWYAK6XR.js");
           return resume({ sessionManager: this.ctx.sessionManager, args });
         }
         case "/sessions": {
@@ -8592,8 +8681,21 @@ var SlashCommandHandler = class {
           });
           return null;
         }
+        case "/share": {
+          const { execute } = await import("./share-3PSV53CQ.js");
+          await execute(args.join(" "), {
+            sessionManager: this.ctx.sessionManager,
+            currentSession: this.ctx.currentSession,
+            model: this.ctx.model,
+            provider: this.ctx.provider,
+            config: this.ctx.config,
+            getTotalTokensUsed: this.ctx.getTotalTokensUsed,
+            workspaceRoot: this.ctx.workspaceRoot
+          });
+          return null;
+        }
         case "/status": {
-          const { status } = await import("./status-UT4UQN3H.js");
+          const { status } = await import("./status-GPAZ67ZZ.js");
           return status(this.ctx);
         }
         case "/login": {
@@ -8885,184 +8987,1164 @@ var ProjectManager = class {
   }
 };
 
-// src/core/agents/AgentDelegator.ts
-import chalk10 from "chalk";
-
-// src/core/agents/SubAgent.ts
-import chalk9 from "chalk";
-var DELEGATION_TOOL_DEFINITIONS = [
-  {
-    name: "delegate_task",
-    description: "Delegate a task to another specialized sub-agent",
-    parameters: {
-      type: "object",
-      properties: {
-        agent_name: { type: "string", description: "Name of the agent to delegate to" },
-        task: { type: "string", description: "Task description for the sub-agent" }
-      },
-      required: ["agent_name", "task"]
+// src/onboarding/projectAnalyzer.ts
+import { pathExists, readJson, readFile } from "fs-extra";
+import { join as join2 } from "path";
+var ProjectAnalyzer = class {
+  constructor(workspaceRoot) {
+    this.workspaceRoot = workspaceRoot;
+  }
+  /**
+   * Analyze the workspace and return project information
+   */
+  async analyze() {
+    const info = {};
+    await this.analyzeNodeProject(info);
+    await this.analyzeRustProject(info);
+    await this.analyzeGoProject(info);
+    await this.analyzePythonProject(info);
+    return info;
+  }
+  /**
+   * Analyze Node.js/JavaScript/TypeScript project
+   */
+  async analyzeNodeProject(info) {
+    const pkgPath = join2(this.workspaceRoot, "package.json");
+    if (!await pathExists(pkgPath)) {
+      return;
     }
-  },
-  {
-    name: "delegate_parallel",
-    description: "Run multiple sub-agents in parallel (max 5)",
-    parameters: {
-      type: "object",
-      properties: {
-        tasks: { type: "array", description: "Array of {agent_name, task} objects" }
-      },
-      required: ["tasks"]
+    try {
+      const pkg = await readJson(pkgPath);
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps.typescript || pkg.devDependencies?.typescript) {
+        info.language = "TypeScript";
+      } else {
+        info.language = "JavaScript";
+      }
+      info.framework = this.detectNodeFramework(deps);
+      info.packageManager = await this.detectNodePackageManager();
+      info.testFramework = this.detectNodeTestFramework(deps);
+      info.linter = this.detectNodeLinter(deps);
+      info.formatter = this.detectNodeFormatter(deps);
+      info.buildTool = this.detectNodeBuildTool(deps);
+    } catch {
     }
   }
-];
-var SubAgent = class {
-  constructor(config, llm, actionExecutor, options) {
-    this.config = config;
-    this.llm = llm;
-    this.actionExecutor = actionExecutor;
-    this.delegator = null;
-    this.name = config.name;
-    this.options = options;
-    const canDelegate = options.depth < options.maxDepth;
-    const allowedTools = new Set(config.tools);
-    let definitions = DEFAULT_TOOL_DEFINITIONS.filter((def) => allowedTools.has(def.name));
-    if (canDelegate) {
-      definitions = [...definitions, ...DELEGATION_TOOL_DEFINITIONS];
+  /**
+   * Detect Node.js framework from dependencies
+   */
+  detectNodeFramework(deps) {
+    if (deps.next) return "Next.js";
+    if (deps.nuxt) return "Nuxt";
+    if (deps["@remix-run/node"] || deps["@remix-run/react"]) return "Remix";
+    if (deps["@angular/core"]) return "Angular";
+    if (deps.svelte) return "Svelte";
+    if (deps.vue) return "Vue";
+    if (deps.react) return "React";
+    if (deps.solid) return "Solid";
+    if (deps["@nestjs/core"]) return "NestJS";
+    if (deps.fastify) return "Fastify";
+    if (deps.hono) return "Hono";
+    if (deps.koa) return "Koa";
+    if (deps.express) return "Express";
+    return void 0;
+  }
+  /**
+   * Detect Node.js package manager from lockfiles
+   */
+  async detectNodePackageManager() {
+    if (await pathExists(join2(this.workspaceRoot, "bun.lockb")) || await pathExists(join2(this.workspaceRoot, "bun.lock"))) {
+      return "bun";
     }
-    const toolFilter = new ToolFilter(options.clientContext);
-    definitions = toolFilter.filterDefinitions(definitions);
-    if (canDelegate) {
-      this.delegator = new AgentDelegator(llm, actionExecutor, {
-        clientContext: options.clientContext,
-        currentDepth: options.depth,
-        maxDepth: options.maxDepth
-      });
+    if (await pathExists(join2(this.workspaceRoot, "pnpm-lock.yaml"))) {
+      return "pnpm";
     }
-    this.toolManager = new ToolManager({
-      executor: async (action, context) => {
-        if (action.type === "delegate_task" && this.delegator) {
-          return this.delegator.delegateTask(
-            action.agent_name,
-            action.task
-          );
-        }
-        if (action.type === "delegate_parallel" && this.delegator) {
-          return this.delegator.delegateParallel(action.tasks);
-        }
-        return this.actionExecutor.execute(action, context);
-      },
-      confirmApproval: async () => true,
-      // Sub-agents auto-approve (inherit from main agent in future)
-      definitions,
-      clientContext: options.clientContext
-    });
-    const enhancedSystemPrompt = this.buildSystemPrompt(config.systemPrompt, definitions);
-    this.conversation = new ConversationManager();
-    this.conversation.reset(enhancedSystemPrompt);
+    if (await pathExists(join2(this.workspaceRoot, "yarn.lock"))) {
+      return "yarn";
+    }
+    if (await pathExists(join2(this.workspaceRoot, "package-lock.json"))) {
+      return "npm";
+    }
+    return "npm";
   }
   /**
-   * Build system prompt with tool signatures for the LLM
+   * Detect Node.js test framework
    */
-  buildSystemPrompt(basePrompt, tools) {
-    const toolSignatures = tools.map((def) => this.formatToolSignature(def)).join("\n");
-    return [
-      basePrompt,
-      "",
-      "## Available Tools",
-      "You have access to the following tools. Use them when needed:",
-      "",
-      toolSignatures,
-      "",
-      "## Response Format",
-      "Always respond with structured JSON:",
-      "```json",
-      "{",
-      '  "thought": "Your reasoning about what to do next",',
-      '  "toolCalls": [{"tool": "tool_name", "args": {...}}],',
-      '  "finalResponse": "Your final answer when done (omit toolCalls if providing this)"',
-      "}",
-      "```",
-      "",
-      `Depth: ${this.options.depth}/${this.options.maxDepth} ${this.delegator ? "(can delegate further)" : "(max depth reached)"}`
-    ].join("\n");
+  detectNodeTestFramework(deps) {
+    if (deps.vitest) return "Vitest";
+    if (deps.jest) return "Jest";
+    if (deps.mocha) return "Mocha";
+    if (deps.ava) return "AVA";
+    if (deps["@playwright/test"]) return "Playwright";
+    if (deps.cypress) return "Cypress";
+    if (deps.puppeteer) return "Puppeteer";
+    return void 0;
   }
   /**
-   * Format a tool definition as a signature string
+   * Detect Node.js linter
    */
-  formatToolSignature(def) {
-    const params = def.parameters?.properties ? Object.entries(def.parameters.properties).map(([name, prop]) => {
-      const required = def.parameters?.required?.includes(name) ? "" : "?";
-      return `${name}${required}: ${prop.type}`;
-    }).join(", ") : "";
-    return `- ${def.name}(${params}): ${def.description}`;
-  }
-  async run(task) {
-    console.log(chalk9.cyan(`
-\u{1F916} Sub-agent '${this.name}' starting task... (depth ${this.options.depth}/${this.options.maxDepth})`));
-    this.conversation.addMessage({ role: "user", content: task });
-    const tools = this.toolManager.toFunctionDefinitions();
-    const maxIterations = 10;
-    for (let i = 0; i < maxIterations; i++) {
-      const completion = await this.llm.complete({
-        messages: this.conversation.history(),
-        model: this.config.model,
-        temperature: 0.2,
-        tools: tools.length > 0 ? tools : void 0,
-        toolChoice: tools.length > 0 ? "auto" : void 0
-      });
-      const payload = this.parseResponse(completion);
-      if (completion.toolCalls?.length) {
-        this.conversation.addMessage({
-          role: "assistant",
-          content: completion.content || ""
-        });
-      } else {
-        this.conversation.addMessage({ role: "assistant", content: completion.content });
-      }
-      if (payload.thought) {
-        console.log(chalk9.gray(`[${this.name}] ${payload.thought}`));
-      }
-      if (payload.toolCalls && payload.toolCalls.length > 0) {
-        const results = await this.toolManager.execute(payload.toolCalls);
-        for (let j = 0; j < results.length; j++) {
-          const result = results[j];
-          const toolCall = completion.toolCalls?.[j];
-          const content = result.success ? result.output ?? "(no output)" : result.error ?? "Tool failed";
-          this.conversation.addMessage({
-            role: "tool",
-            name: result.tool,
-            content,
-            tool_call_id: toolCall?.id
-          });
-          if (!result.success) {
-            console.log(chalk9.red(`[${this.name}] Tool ${result.tool} failed: ${content}`));
-          }
-        }
-        continue;
-      }
-      const response = payload.finalResponse ?? payload.response ?? completion.content;
-      console.log(chalk9.cyan(`[${this.name}] Finished.`));
-      return response;
-    }
-    return `[${this.name}] Failed to complete task within ${maxIterations} iterations.`;
+  detectNodeLinter(deps) {
+    if (deps["@biomejs/biome"]) return "Biome";
+    if (deps.eslint) return "ESLint";
+    if (deps.oxlint) return "Oxlint";
+    return void 0;
   }
   /**
-   * Parse LLM response, preferring native tool calls over JSON parsing
+   * Detect Node.js formatter
    */
-  parseResponse(completion) {
-    if (completion.toolCalls && completion.toolCalls.length > 0) {
-      return {
-        thought: completion.content || void 0,
-        toolCalls: completion.toolCalls.map((tc) => ({
-          tool: tc.function.name,
-          args: this.safeParseJson(tc.function.arguments)
-        }))
-      };
-    }
-    return this.parsePayload(completion.content);
+  detectNodeFormatter(deps) {
+    if (deps.prettier) return "Prettier";
+    if (deps["@biomejs/biome"]) return "Biome";
+    if (deps.dprint) return "dprint";
+    return void 0;
   }
   /**
-   * Safely parse JSON, returning empty object on failure
+   * Detect Node.js build tool
+   */
+  detectNodeBuildTool(deps) {
+    if (deps.vite) return "Vite";
+    if (deps.tsup) return "tsup";
+    if (deps.esbuild) return "esbuild";
+    if (deps.rollup) return "Rollup";
+    if (deps.webpack) return "Webpack";
+    if (deps.parcel) return "Parcel";
+    if (deps.turbopack || deps.turbo) return "Turbopack";
+    return void 0;
+  }
+  /**
+   * Analyze Rust project
+   */
+  async analyzeRustProject(info) {
+    const cargoPath = join2(this.workspaceRoot, "Cargo.toml");
+    if (!await pathExists(cargoPath)) {
+      return;
+    }
+    info.language = "Rust";
+    info.packageManager = "cargo";
+    try {
+      const cargoContent = await readFile(cargoPath, "utf-8");
+      if (cargoContent.includes("actix-web")) {
+        info.framework = "Actix";
+      } else if (cargoContent.includes("axum")) {
+        info.framework = "Axum";
+      } else if (cargoContent.includes("rocket")) {
+        info.framework = "Rocket";
+      } else if (cargoContent.includes("warp")) {
+        info.framework = "Warp";
+      } else if (cargoContent.includes("tauri")) {
+        info.framework = "Tauri";
+      }
+    } catch {
+    }
+  }
+  /**
+   * Analyze Go project
+   */
+  async analyzeGoProject(info) {
+    const goModPath = join2(this.workspaceRoot, "go.mod");
+    if (!await pathExists(goModPath)) {
+      return;
+    }
+    info.language = "Go";
+    info.packageManager = "go";
+    try {
+      const goModContent = await readFile(goModPath, "utf-8");
+      if (goModContent.includes("github.com/gin-gonic/gin")) {
+        info.framework = "Gin";
+      } else if (goModContent.includes("github.com/gofiber/fiber")) {
+        info.framework = "Fiber";
+      } else if (goModContent.includes("github.com/labstack/echo")) {
+        info.framework = "Echo";
+      } else if (goModContent.includes("github.com/gorilla/mux")) {
+        info.framework = "Gorilla";
+      }
+    } catch {
+    }
+  }
+  /**
+   * Analyze Python project
+   */
+  async analyzePythonProject(info) {
+    const pyprojectPath = join2(this.workspaceRoot, "pyproject.toml");
+    const requirementsPath = join2(this.workspaceRoot, "requirements.txt");
+    const poetryLockPath = join2(this.workspaceRoot, "poetry.lock");
+    const pipfilePath = join2(this.workspaceRoot, "Pipfile");
+    const hasPyproject = await pathExists(pyprojectPath);
+    const hasRequirements = await pathExists(requirementsPath);
+    if (!hasPyproject && !hasRequirements) {
+      return;
+    }
+    info.language = "Python";
+    if (await pathExists(poetryLockPath)) {
+      info.packageManager = "poetry";
+    } else if (await pathExists(pipfilePath)) {
+      info.packageManager = "pipenv";
+    } else if (hasPyproject) {
+      info.packageManager = "pip";
+    } else {
+      info.packageManager = "pip";
+    }
+    let depsContent = "";
+    try {
+      if (hasRequirements) {
+        depsContent = await readFile(requirementsPath, "utf-8");
+      } else if (hasPyproject) {
+        depsContent = await readFile(pyprojectPath, "utf-8");
+      }
+      if (depsContent.includes("django")) {
+        info.framework = "Django";
+      } else if (depsContent.includes("fastapi")) {
+        info.framework = "FastAPI";
+      } else if (depsContent.includes("flask")) {
+        info.framework = "Flask";
+      } else if (depsContent.includes("starlette")) {
+        info.framework = "Starlette";
+      } else if (depsContent.includes("tornado")) {
+        info.framework = "Tornado";
+      }
+      if (depsContent.includes("pytest")) {
+        info.testFramework = "pytest";
+      } else if (depsContent.includes("unittest")) {
+        info.testFramework = "unittest";
+      } else if (depsContent.includes("nose")) {
+        info.testFramework = "nose";
+      }
+      if (depsContent.includes("ruff")) {
+        info.linter = "Ruff";
+      } else if (depsContent.includes("flake8")) {
+        info.linter = "Flake8";
+      } else if (depsContent.includes("pylint")) {
+        info.linter = "Pylint";
+      }
+      if (depsContent.includes("black")) {
+        info.formatter = "Black";
+      } else if (depsContent.includes("ruff")) {
+        info.formatter = "Ruff";
+      } else if (depsContent.includes("autopep8")) {
+        info.formatter = "autopep8";
+      }
+    } catch {
+    }
+  }
+};
+
+// src/onboarding/agentsGenerator.ts
+var AgentsGenerator = class {
+  /**
+   * Generate AGENTS.md content
+   */
+  generateContent(info, options) {
+    const sections = [];
+    sections.push("# AGENTS.md");
+    sections.push("");
+    sections.push("This file helps Autohand understand how to work with this project.");
+    sections.push("");
+    sections.push(this.generateProjectOverview(info));
+    if (info.packageManager) {
+      sections.push(this.generateCommandsSection(info));
+    }
+    if (info.testFramework) {
+      sections.push(this.generateTestingSection(info));
+    }
+    if (info.framework) {
+      const frameworkSection = this.generateFrameworkSection(info);
+      if (frameworkSection) {
+        sections.push(frameworkSection);
+      }
+    }
+    sections.push(this.generateCodeStyleSection(info));
+    sections.push(this.generateConstraintsSection());
+    if (options?.customSections) {
+      for (const section of options.customSections) {
+        sections.push(`## ${section.title}`);
+        sections.push("");
+        sections.push(section.content);
+        sections.push("");
+      }
+    }
+    return sections.join("\n");
+  }
+  /**
+   * Generate project overview section
+   */
+  generateProjectOverview(info) {
+    const lines = [];
+    lines.push("## Project Overview");
+    lines.push("");
+    if (info.language) {
+      lines.push(`- **Language**: ${info.language}`);
+    }
+    if (info.framework) {
+      lines.push(`- **Framework**: ${info.framework}`);
+    }
+    if (info.packageManager) {
+      lines.push(`- **Package Manager**: ${info.packageManager}`);
+    }
+    if (info.testFramework) {
+      lines.push(`- **Test Framework**: ${info.testFramework}`);
+    }
+    if (info.buildTool) {
+      lines.push(`- **Build Tool**: ${info.buildTool}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate commands section based on package manager
+   */
+  generateCommandsSection(info) {
+    const lines = [];
+    lines.push("## Commands");
+    lines.push("");
+    const pm = info.packageManager;
+    if (info.language === "Rust") {
+      lines.push("- **Build**: `cargo build`");
+      lines.push("- **Build (release)**: `cargo build --release`");
+      lines.push("- **Run**: `cargo run`");
+      lines.push("- **Test**: `cargo test`");
+      lines.push("- **Check**: `cargo check`");
+      lines.push("- **Format**: `cargo fmt`");
+      lines.push("- **Lint**: `cargo clippy`");
+    } else if (info.language === "Go") {
+      lines.push("- **Build**: `go build`");
+      lines.push("- **Run**: `go run .`");
+      lines.push("- **Test**: `go test ./...`");
+      lines.push("- **Format**: `go fmt ./...`");
+      lines.push("- **Vet**: `go vet ./...`");
+    } else if (info.language === "Python") {
+      if (pm === "poetry") {
+        lines.push("- **Install**: `poetry install`");
+        lines.push("- **Run**: `poetry run python main.py`");
+        lines.push("- **Add dependency**: `poetry add <package>`");
+        if (info.testFramework) {
+          lines.push(`- **Test**: \`poetry run pytest\``);
+        }
+      } else if (pm === "pipenv") {
+        lines.push("- **Install**: `pipenv install`");
+        lines.push("- **Run**: `pipenv run python main.py`");
+        if (info.testFramework) {
+          lines.push(`- **Test**: \`pipenv run pytest\``);
+        }
+      } else {
+        lines.push("- **Install**: `pip install -r requirements.txt`");
+        lines.push("- **Run**: `python main.py`");
+        if (info.testFramework) {
+          lines.push(`- **Test**: \`pytest\``);
+        }
+      }
+    } else {
+      const run = pm === "npm" ? "npm run" : pm;
+      const install = pm === "npm" ? "npm install" : `${pm} install`;
+      lines.push(`- **Install**: \`${install}\``);
+      lines.push(`- **Dev**: \`${run} dev\``);
+      lines.push(`- **Build**: \`${run} build\``);
+      if (info.testFramework) {
+        lines.push(`- **Test**: \`${run} test\``);
+      }
+      if (info.linter) {
+        lines.push(`- **Lint**: \`${run} lint\``);
+      }
+      if (info.formatter) {
+        lines.push(`- **Format**: \`${run} format\``);
+      }
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate testing section
+   */
+  generateTestingSection(info) {
+    const lines = [];
+    lines.push("## Testing");
+    lines.push("");
+    lines.push(`This project uses **${info.testFramework}** for testing.`);
+    lines.push("");
+    lines.push("- Write tests for new features before implementation");
+    lines.push("- Run tests before committing changes");
+    lines.push("- Aim for good test coverage on critical paths");
+    if (info.testFramework === "Vitest" || info.testFramework === "Jest") {
+      lines.push("- Use `describe` and `it` blocks to organize tests");
+      lines.push("- Mock external dependencies when appropriate");
+    } else if (info.testFramework === "pytest") {
+      lines.push("- Use fixtures for shared test setup");
+      lines.push("- Use `pytest.mark` for test categorization");
+    } else if (info.testFramework === "Playwright" || info.testFramework === "Cypress") {
+      lines.push("- Write E2E tests for critical user flows");
+      lines.push("- Keep selectors stable and meaningful");
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate framework-specific section
+   */
+  generateFrameworkSection(info) {
+    const lines = [];
+    switch (info.framework) {
+      case "Next.js":
+        lines.push("## Next.js Guidelines");
+        lines.push("");
+        lines.push("- Use the App Router for new pages (`app/` directory)");
+        lines.push("- Prefer Server Components by default");
+        lines.push('- Use `"use client"` only when needed for interactivity');
+        lines.push("- Keep API routes in `app/api/`");
+        lines.push("- Use `next/image` for optimized images");
+        lines.push("- Use `next/link` for client-side navigation");
+        break;
+      case "React":
+        lines.push("## React Guidelines");
+        lines.push("");
+        lines.push("- Use functional components with hooks");
+        lines.push("- Keep components small and focused");
+        lines.push("- Use custom hooks to share logic");
+        lines.push("- Prefer composition over inheritance");
+        lines.push("- Use TypeScript interfaces for props");
+        break;
+      case "Vue":
+        lines.push("## Vue Guidelines");
+        lines.push("");
+        lines.push("- Use Composition API for new components");
+        lines.push("- Keep components in single-file format (.vue)");
+        lines.push("- Use composables to share logic");
+        break;
+      case "Express":
+        lines.push("## Express Guidelines");
+        lines.push("");
+        lines.push("- Use middleware for cross-cutting concerns");
+        lines.push("- Keep route handlers thin, delegate to services");
+        lines.push("- Use async/await with proper error handling");
+        lines.push("- Validate request input before processing");
+        break;
+      case "FastAPI":
+        lines.push("## FastAPI Guidelines");
+        lines.push("");
+        lines.push("- Use Pydantic models for request/response validation");
+        lines.push("- Use dependency injection for shared resources");
+        lines.push("- Keep endpoints in organized routers");
+        lines.push("- Use async functions for I/O operations");
+        break;
+      case "Django":
+        lines.push("## Django Guidelines");
+        lines.push("");
+        lines.push("- Follow Django project structure conventions");
+        lines.push("- Use class-based views where appropriate");
+        lines.push("- Keep business logic in models or services");
+        lines.push("- Use Django ORM for database operations");
+        break;
+      case "Flask":
+        lines.push("## Flask Guidelines");
+        lines.push("");
+        lines.push("- Use blueprints to organize routes");
+        lines.push("- Keep route handlers focused");
+        lines.push("- Use Flask extensions for common functionality");
+        break;
+      case "NestJS":
+        lines.push("## NestJS Guidelines");
+        lines.push("");
+        lines.push("- Follow module-based architecture");
+        lines.push("- Use dependency injection");
+        lines.push("- Use decorators for metadata");
+        lines.push("- Keep controllers thin, services fat");
+        break;
+      default:
+        return null;
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate code style section
+   */
+  generateCodeStyleSection(info) {
+    const lines = [];
+    lines.push("## Code Style");
+    lines.push("");
+    if (info.language === "TypeScript") {
+      lines.push("- Use strict TypeScript settings");
+      lines.push("- Define types/interfaces for data structures");
+      lines.push("- Avoid `any` type - use `unknown` if type is truly unknown");
+      lines.push("- Use type inference where obvious");
+    } else if (info.language === "Python") {
+      lines.push("- Follow PEP 8 style guidelines");
+      lines.push("- Use type hints for function signatures");
+      lines.push("- Use docstrings for public functions");
+    } else if (info.language === "Rust") {
+      lines.push("- Follow Rust naming conventions (snake_case for functions)");
+      lines.push("- Use descriptive error types");
+      lines.push("- Prefer `Result` over panicking");
+    } else if (info.language === "Go") {
+      lines.push("- Follow Go idioms and conventions");
+      lines.push("- Use short variable names in small scopes");
+      lines.push("- Handle errors explicitly");
+    }
+    lines.push("- Follow existing patterns in the codebase");
+    lines.push("- Use meaningful variable and function names");
+    lines.push("- Add comments for complex logic");
+    lines.push("- Keep functions focused and small");
+    if (info.linter) {
+      lines.push(`- Run **${info.linter}** before committing`);
+    }
+    if (info.formatter) {
+      lines.push(`- Format code with **${info.formatter}**`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate constraints section
+   */
+  generateConstraintsSection() {
+    const lines = [];
+    lines.push("## Constraints");
+    lines.push("");
+    lines.push("- Do not modify files outside the project directory");
+    lines.push("- Ask before making breaking changes");
+    lines.push("- Prefer editing existing files over creating new ones");
+    lines.push("- Do not delete files without confirmation");
+    lines.push("- Keep dependencies minimal - avoid adding new ones without good reason");
+    lines.push("- Do not commit sensitive data (API keys, secrets, credentials)");
+    lines.push("");
+    return lines.join("\n");
+  }
+};
+
+// src/onboarding/setupWizard.ts
+import chalk9 from "chalk";
+import enquirer2 from "enquirer";
+import { pathExists as pathExists2, writeFile } from "fs-extra";
+import { join as join3 } from "path";
+var ASCII_FRIEND = [
+  "\u2880\u2874\u281B\u281B\u283B\u28F7\u2844\u2800\u28E0\u2876\u281F\u281B\u283B\u28F6\u2844\u2880\u28F4\u287E\u281B\u281B\u28BF\u28E6\u2800\u2880\u28F4\u281E\u281B\u281B\u2836\u2840",
+  "\u284E\u2800\u28B0\u28F6\u2846\u2808\u28FF\u28F4\u28FF\u2801\u28F4\u28F6\u2844\u2818\u28FF\u28FE\u284F\u2880\u28F6\u28E6\u2800\u28BB\u2847\u28FF\u2803\u28A0\u28F6\u2846\u2800\u28B9",
+  "\u28A7\u2800\u2818\u281B\u2803\u28A0\u287F\u2819\u28FF\u2840\u2819\u281B\u2803\u28F0\u287F\u28BB\u28E7\u2808\u281B\u281B\u2880\u28FE\u2807\u28BB\u28C6\u2808\u281B\u280B\u2800\u287C",
+  "\u2808\u283B\u28B6\u28F6\u287E\u281F\u2801\u2800\u2818\u283F\u28B6\u28F6\u287E\u281F\u2801\u2800\u2819\u2837\u28F6\u28F6\u283F\u280B\u2800\u2808\u283B\u2837\u28F6\u2876\u281A\u2801",
+  "\u2880\u28F4\u283F\u283F\u2837\u28E6\u2840\u2800\u28E0\u28F6\u283F\u283B\u28B7\u28E6\u2840\u2800\u28E0\u287E\u281F\u283F\u28F6\u28C4\u2800\u2880\u28F4\u287E\u283F\u283F\u28F6\u28C4",
+  "\u287E\u2803\u28A0\u28E4\u2844\u2818\u28FF\u28E0\u28FF\u2801\u28E0\u28E4\u2844\u2839\u28F7\u28FC\u284F\u2880\u28E4\u28E4\u2808\u28BF\u2846\u28FE\u280F\u2880\u28E4\u28C4\u2808\u28BF",
+  "\u28A7\u2840\u2838\u283F\u2807\u2880\u28FF\u283A\u28FF\u2840\u283B\u283F\u2803\u28B0\u28FF\u28BF\u28C7\u2808\u283F\u283F\u2800\u28FC\u2847\u28BF\u28C7\u2818\u283F\u2807\u2800\u28F8",
+  "\u2808\u28BF\u28E6\u28E4\u28F4\u287F\u2803\u2800\u2819\u28B7\u28E6\u28E4\u28F6\u287F\u2801\u2808\u283B\u28F7\u28E4\u28E4\u287E\u281B\u2800\u2808\u28BF\u28E6\u28E4\u28E4\u2834\u2801"
+].join("\n");
+var SetupWizard = class {
+  constructor(workspaceRoot, existingConfig) {
+    this.workspaceRoot = workspaceRoot;
+    this.existingConfig = existingConfig ?? null;
+    this.state = {
+      currentStep: "welcome",
+      skipped: [],
+      completed: false
+    };
+  }
+  /**
+   * Run the full onboarding wizard
+   */
+  async run(options) {
+    if (!options?.force && this.isAlreadyConfigured()) {
+      return {
+        success: true,
+        config: {},
+        skippedSteps: ["welcome", "provider", "apiKey", "model", "telemetry", "preferences", "agentsFile"],
+        cancelled: false
+      };
+    }
+    try {
+      if (!options?.skipWelcome) {
+        await this.showWelcome();
+      }
+      const provider = await this.promptProvider();
+      if (!provider) return this.cancelled();
+      if (this.requiresApiKey(provider)) {
+        const apiKey = await this.promptApiKey(provider);
+        if (apiKey === null) return this.cancelled();
+      }
+      const model = await this.promptModel(provider);
+      if (!model) return this.cancelled();
+      await this.promptTelemetry();
+      if (!options?.quickSetup) {
+        await this.promptPreferences();
+      } else {
+        this.state.skipped.push("preferences");
+      }
+      await this.promptAgentsFile();
+      return this.complete();
+    } catch (error) {
+      if (this.isCancellation(error)) {
+        return this.cancelled();
+      }
+      throw error;
+    }
+  }
+  /**
+   * Check if configuration is already complete
+   */
+  isAlreadyConfigured() {
+    if (!this.existingConfig) return false;
+    const provider = this.existingConfig.provider;
+    if (!provider) return false;
+    const providerConfig = getProviderConfig(this.existingConfig, provider);
+    return providerConfig !== null;
+  }
+  /**
+   * Show welcome screen
+   */
+  async showWelcome() {
+    console.clear();
+    console.log(chalk9.gray(ASCII_FRIEND));
+    console.log();
+    console.log(chalk9.cyan.bold("  Welcome to Autohand!"));
+    console.log(chalk9.gray("  Your super fast AI coding agent"));
+    console.log();
+    console.log(chalk9.white("  Let's get you set up in just a few steps."));
+    console.log();
+    await this.pressEnter();
+  }
+  /**
+   * Prompt for provider selection
+   */
+  async promptProvider() {
+    this.state.currentStep = "provider";
+    const providers = ProviderFactory.getProviderNames();
+    const choices = providers.map((p) => ({
+      name: p,
+      message: this.getProviderDisplayName(p),
+      hint: this.getProviderHint(p)
+    }));
+    const result = await enquirer2.prompt({
+      type: "select",
+      name: "provider",
+      message: "Which LLM provider would you like to use?",
+      choices,
+      initial: this.existingConfig?.provider ? providers.indexOf(this.existingConfig.provider) : 0
+    });
+    this.state.provider = result.provider;
+    return result.provider;
+  }
+  /**
+   * Prompt for API key (cloud providers)
+   */
+  async promptApiKey(provider) {
+    this.state.currentStep = "apiKey";
+    const existingKey = this.getExistingApiKey(provider);
+    if (existingKey && existingKey !== "replace-me") {
+      const { useExisting } = await enquirer2.prompt({
+        type: "confirm",
+        name: "useExisting",
+        message: `Use existing ${this.getProviderDisplayName(provider)} API key? (ends with ...${existingKey.slice(-4)})`,
+        initial: true
+      });
+      if (useExisting) {
+        this.state.apiKey = existingKey;
+        return existingKey;
+      }
+    }
+    console.log(chalk9.gray(`
+  Get your API key at: ${this.getApiKeyUrl(provider)}
+`));
+    const result = await enquirer2.prompt({
+      type: "password",
+      name: "apiKey",
+      message: `Enter your ${this.getProviderDisplayName(provider)} API key`,
+      validate: (val) => {
+        const v = val;
+        if (!v?.trim()) return "API key is required";
+        if (v.length < 10) return "API key seems too short";
+        return true;
+      }
+    });
+    this.state.apiKey = result.apiKey.trim();
+    return this.state.apiKey;
+  }
+  /**
+   * Prompt for model selection
+   */
+  async promptModel(provider) {
+    this.state.currentStep = "model";
+    const defaultModel = this.getDefaultModel(provider);
+    const result = await enquirer2.prompt({
+      type: "input",
+      name: "model",
+      message: "Enter model ID",
+      initial: defaultModel,
+      validate: (val) => {
+        const v = val;
+        return v?.trim() ? true : "Model is required";
+      }
+    });
+    this.state.model = result.model.trim();
+    return this.state.model;
+  }
+  /**
+   * Prompt for telemetry preference
+   */
+  async promptTelemetry() {
+    this.state.currentStep = "telemetry";
+    console.log();
+    console.log(chalk9.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log(chalk9.white.bold("  Help us improve Autohand"));
+    console.log(chalk9.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log();
+    console.log(chalk9.gray("  We collect anonymous usage data to understand how"));
+    console.log(chalk9.gray("  Autohand is used and where we can make it better."));
+    console.log();
+    console.log(chalk9.gray("  What we collect:"));
+    console.log(chalk9.gray("  - Command usage (which features are popular)"));
+    console.log(chalk9.gray("  - Error rates (to fix bugs faster)"));
+    console.log(chalk9.gray("  - Performance metrics (to speed things up)"));
+    console.log();
+    console.log(chalk9.gray("  What we never collect:"));
+    console.log(chalk9.gray("  - Your code or file contents"));
+    console.log(chalk9.gray("  - API keys or credentials"));
+    console.log(chalk9.gray("  - Personal information"));
+    console.log();
+    const { telemetryEnabled } = await enquirer2.prompt({
+      type: "confirm",
+      name: "telemetryEnabled",
+      message: "Share anonymous usage data to help improve Autohand?",
+      initial: true
+    });
+    this.state.telemetryEnabled = telemetryEnabled;
+    if (telemetryEnabled) {
+      console.log(chalk9.green("  Thanks for helping us improve Autohand!"));
+    } else {
+      console.log(chalk9.gray("  No problem! You can change this anytime in config."));
+    }
+  }
+  /**
+   * Prompt for additional preferences
+   */
+  async promptPreferences() {
+    this.state.currentStep = "preferences";
+    const { configurePrefs } = await enquirer2.prompt({
+      type: "confirm",
+      name: "configurePrefs",
+      message: "Would you like to configure additional preferences? (theme, auto-confirm)",
+      initial: false
+    });
+    if (!configurePrefs) {
+      this.state.skipped.push("preferences");
+      return;
+    }
+    const themes = ["dark", "light", "dracula", "sandy", "tui"];
+    const themeDescriptions = {
+      dark: "Default dark theme",
+      light: "Light theme for light backgrounds",
+      dracula: "Popular Dracula color scheme",
+      sandy: "Warm, earthy desert tones",
+      tui: "New Zealand inspired colors"
+    };
+    const { theme } = await enquirer2.prompt({
+      type: "select",
+      name: "theme",
+      message: "Select a theme",
+      choices: themes.map((t) => ({ name: t, message: t, hint: themeDescriptions[t] })),
+      initial: 0
+    });
+    const { autoConfirm } = await enquirer2.prompt({
+      type: "confirm",
+      name: "autoConfirm",
+      message: "Auto-confirm non-destructive actions?",
+      initial: false
+    });
+    const { checkForUpdates: checkForUpdates2 } = await enquirer2.prompt({
+      type: "confirm",
+      name: "checkForUpdates",
+      message: "Check for updates on startup?",
+      initial: true
+    });
+    this.state.preferences = { theme, autoConfirm, checkForUpdates: checkForUpdates2 };
+  }
+  /**
+   * Prompt for AGENTS.md creation
+   */
+  async promptAgentsFile() {
+    this.state.currentStep = "agentsFile";
+    const agentsPath = join3(this.workspaceRoot, "AGENTS.md");
+    const exists = await pathExists2(agentsPath);
+    if (exists) {
+      const { overwrite } = await enquirer2.prompt({
+        type: "confirm",
+        name: "overwrite",
+        message: "AGENTS.md already exists. Would you like to regenerate it?",
+        initial: false
+      });
+      if (!overwrite) {
+        this.state.skipped.push("agentsFile");
+        console.log(chalk9.gray("  Keeping existing AGENTS.md"));
+        return;
+      }
+    } else {
+      console.log();
+      console.log(chalk9.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log(chalk9.white.bold("  Project Configuration"));
+      console.log(chalk9.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+      console.log();
+      console.log(chalk9.gray("  AGENTS.md helps Autohand understand your project better."));
+      console.log(chalk9.gray("  It contains instructions specific to your codebase."));
+      console.log();
+      const { createAgents } = await enquirer2.prompt({
+        type: "confirm",
+        name: "createAgents",
+        message: "Generate AGENTS.md based on your project?",
+        initial: true
+      });
+      if (!createAgents) {
+        this.state.skipped.push("agentsFile");
+        console.log(chalk9.gray("  You can create it later with /init"));
+        return;
+      }
+    }
+    console.log();
+    console.log(chalk9.gray("  Analyzing your project..."));
+    const analyzer = new ProjectAnalyzer(this.workspaceRoot);
+    const projectInfo = await analyzer.analyze();
+    if (Object.keys(projectInfo).length > 0) {
+      console.log();
+      console.log(chalk9.gray("  Detected:"));
+      if (projectInfo.language) {
+        console.log(chalk9.white(`  - Language: ${projectInfo.language}`));
+      }
+      if (projectInfo.framework) {
+        console.log(chalk9.white(`  - Framework: ${projectInfo.framework}`));
+      }
+      if (projectInfo.packageManager) {
+        console.log(chalk9.white(`  - Package manager: ${projectInfo.packageManager}`));
+      }
+      if (projectInfo.testFramework) {
+        console.log(chalk9.white(`  - Test framework: ${projectInfo.testFramework}`));
+      }
+    }
+    const generator = new AgentsGenerator();
+    const content = generator.generateContent(projectInfo);
+    await writeFile(agentsPath, content);
+    this.state.agentsFileCreated = true;
+    console.log();
+    console.log(chalk9.green("  Created AGENTS.md"));
+    console.log(chalk9.gray("  You can customize it anytime to improve Autohand's understanding."));
+  }
+  /**
+   * Build final config and return success
+   */
+  complete() {
+    this.state.currentStep = "complete";
+    this.state.completed = true;
+    const config = {
+      provider: this.state.provider
+    };
+    if (this.state.provider) {
+      if (this.requiresApiKey(this.state.provider)) {
+        config[this.state.provider] = {
+          apiKey: this.state.apiKey,
+          model: this.state.model,
+          baseUrl: this.getDefaultBaseUrl(this.state.provider)
+        };
+      } else {
+        config[this.state.provider] = {
+          model: this.state.model,
+          baseUrl: this.getDefaultBaseUrl(this.state.provider)
+        };
+      }
+    }
+    config.telemetry = {
+      enabled: this.state.telemetryEnabled ?? true
+    };
+    if (this.state.preferences) {
+      config.ui = {
+        theme: this.state.preferences.theme,
+        autoConfirm: this.state.preferences.autoConfirm,
+        checkForUpdates: this.state.preferences.checkForUpdates
+      };
+    }
+    this.showCompletionMessage();
+    return {
+      success: true,
+      config,
+      skippedSteps: this.state.skipped,
+      cancelled: false,
+      agentsFileCreated: this.state.agentsFileCreated
+    };
+  }
+  /**
+   * Show setup complete message
+   */
+  showCompletionMessage() {
+    console.log();
+    console.log();
+    console.log(chalk9.green("  Setup complete!"));
+    console.log();
+    console.log(chalk9.gray("  What was created:"));
+    console.log(chalk9.white("  - ~/.autohand/config.json (your settings)"));
+    if (this.state.agentsFileCreated) {
+      console.log(chalk9.white("  - AGENTS.md (project instructions for Autohand)"));
+    }
+    console.log();
+    console.log(chalk9.gray("  Quick tips:"));
+    console.log(chalk9.white("  - Type your request and press Enter to start"));
+    console.log(chalk9.white("  - Use @filename to mention files"));
+    console.log(chalk9.white("  - Type /help for all commands"));
+    console.log(chalk9.white("  - Press Ctrl+C twice to exit"));
+    console.log();
+  }
+  /**
+   * Return cancelled result
+   */
+  cancelled() {
+    return {
+      success: false,
+      config: {},
+      skippedSteps: [],
+      cancelled: true
+    };
+  }
+  // Helper methods
+  requiresApiKey(provider) {
+    return provider === "openrouter" || provider === "openai";
+  }
+  getProviderDisplayName(provider) {
+    const names = {
+      openrouter: "OpenRouter",
+      openai: "OpenAI",
+      ollama: "Ollama",
+      llamacpp: "llama.cpp",
+      mlx: "MLX (Apple Silicon)"
+    };
+    return names[provider] || provider;
+  }
+  getProviderHint(provider) {
+    const hints = {
+      openrouter: "Cloud - Access to 100+ models (Claude, GPT-4, etc.)",
+      openai: "Cloud - Official OpenAI models (GPT-4o, o1, etc.)",
+      ollama: "Local - Run models on your machine (free)",
+      llamacpp: "Local - Fast inference with GGUF models",
+      mlx: "Local - Optimized for Apple Silicon Macs"
+    };
+    return hints[provider] || "";
+  }
+  getApiKeyUrl(provider) {
+    const urls = {
+      openrouter: "https://openrouter.ai/keys",
+      openai: "https://platform.openai.com/api-keys"
+    };
+    return urls[provider] || "";
+  }
+  getDefaultModel(provider) {
+    const defaults = {
+      openrouter: "anthropic/claude-sonnet-4-20250514",
+      openai: "gpt-4o",
+      ollama: "llama3.2:latest",
+      llamacpp: "default",
+      mlx: "mlx-community/Llama-3.2-3B-Instruct-4bit"
+    };
+    return defaults[provider] || "";
+  }
+  getDefaultBaseUrl(provider) {
+    const urls = {
+      openrouter: "https://openrouter.ai/api/v1",
+      openai: "https://api.openai.com/v1",
+      ollama: "http://localhost:11434",
+      llamacpp: "http://localhost:8080",
+      mlx: "http://localhost:8080"
+    };
+    return urls[provider] || "";
+  }
+  getExistingApiKey(provider) {
+    if (!this.existingConfig) return null;
+    const config = this.existingConfig[provider];
+    return config?.apiKey || null;
+  }
+  isCancellation(error) {
+    if (error && typeof error === "object") {
+      const e = error;
+      return e.code === "ERR_USE_AFTER_CLOSE" || e.message?.includes("cancelled") || e.message?.includes("canceled");
+    }
+    return false;
+  }
+  async pressEnter() {
+    console.log(chalk9.gray("  Press Enter to continue..."));
+    await enquirer2.prompt({
+      type: "invisible",
+      name: "continue",
+      message: ""
+    });
+  }
+};
+
+// src/core/agents/AgentDelegator.ts
+import chalk11 from "chalk";
+
+// src/core/agents/SubAgent.ts
+import chalk10 from "chalk";
+var DELEGATION_TOOL_DEFINITIONS = [
+  {
+    name: "delegate_task",
+    description: "Delegate a task to another specialized sub-agent",
+    parameters: {
+      type: "object",
+      properties: {
+        agent_name: { type: "string", description: "Name of the agent to delegate to" },
+        task: { type: "string", description: "Task description for the sub-agent" }
+      },
+      required: ["agent_name", "task"]
+    }
+  },
+  {
+    name: "delegate_parallel",
+    description: "Run multiple sub-agents in parallel (max 5)",
+    parameters: {
+      type: "object",
+      properties: {
+        tasks: { type: "array", description: "Array of {agent_name, task} objects" }
+      },
+      required: ["tasks"]
+    }
+  }
+];
+var SubAgent = class {
+  constructor(config, llm, actionExecutor, options) {
+    this.config = config;
+    this.llm = llm;
+    this.actionExecutor = actionExecutor;
+    this.delegator = null;
+    this.name = config.name;
+    this.options = options;
+    const canDelegate = options.depth < options.maxDepth;
+    const allowedTools = new Set(config.tools);
+    let definitions = DEFAULT_TOOL_DEFINITIONS.filter((def) => allowedTools.has(def.name));
+    if (canDelegate) {
+      definitions = [...definitions, ...DELEGATION_TOOL_DEFINITIONS];
+    }
+    const toolFilter = new ToolFilter(options.clientContext);
+    definitions = toolFilter.filterDefinitions(definitions);
+    if (canDelegate) {
+      this.delegator = new AgentDelegator(llm, actionExecutor, {
+        clientContext: options.clientContext,
+        currentDepth: options.depth,
+        maxDepth: options.maxDepth
+      });
+    }
+    this.toolManager = new ToolManager({
+      executor: async (action, context) => {
+        if (action.type === "delegate_task" && this.delegator) {
+          return this.delegator.delegateTask(
+            action.agent_name,
+            action.task
+          );
+        }
+        if (action.type === "delegate_parallel" && this.delegator) {
+          return this.delegator.delegateParallel(action.tasks);
+        }
+        return this.actionExecutor.execute(action, context);
+      },
+      confirmApproval: async () => true,
+      // Sub-agents auto-approve (inherit from main agent in future)
+      definitions,
+      clientContext: options.clientContext
+    });
+    const enhancedSystemPrompt = this.buildSystemPrompt(config.systemPrompt, definitions);
+    this.conversation = new ConversationManager();
+    this.conversation.reset(enhancedSystemPrompt);
+  }
+  /**
+   * Build system prompt with tool signatures for the LLM
+   */
+  buildSystemPrompt(basePrompt, tools) {
+    const toolSignatures = tools.map((def) => this.formatToolSignature(def)).join("\n");
+    return [
+      basePrompt,
+      "",
+      "## Available Tools",
+      "You have access to the following tools. Use them when needed:",
+      "",
+      toolSignatures,
+      "",
+      "## Response Format",
+      "Always respond with structured JSON:",
+      "```json",
+      "{",
+      '  "thought": "Your reasoning about what to do next",',
+      '  "toolCalls": [{"tool": "tool_name", "args": {...}}],',
+      '  "finalResponse": "Your final answer when done (omit toolCalls if providing this)"',
+      "}",
+      "```",
+      "",
+      `Depth: ${this.options.depth}/${this.options.maxDepth} ${this.delegator ? "(can delegate further)" : "(max depth reached)"}`
+    ].join("\n");
+  }
+  /**
+   * Format a tool definition as a signature string
+   */
+  formatToolSignature(def) {
+    const params = def.parameters?.properties ? Object.entries(def.parameters.properties).map(([name, prop]) => {
+      const required = def.parameters?.required?.includes(name) ? "" : "?";
+      return `${name}${required}: ${prop.type}`;
+    }).join(", ") : "";
+    return `- ${def.name}(${params}): ${def.description}`;
+  }
+  async run(task) {
+    console.log(chalk10.cyan(`
+\u{1F916} Sub-agent '${this.name}' starting task... (depth ${this.options.depth}/${this.options.maxDepth})`));
+    this.conversation.addMessage({ role: "user", content: task });
+    const tools = this.toolManager.toFunctionDefinitions();
+    const maxIterations = 10;
+    for (let i = 0; i < maxIterations; i++) {
+      const completion = await this.llm.complete({
+        messages: this.conversation.history(),
+        model: this.config.model,
+        temperature: 0.2,
+        tools: tools.length > 0 ? tools : void 0,
+        toolChoice: tools.length > 0 ? "auto" : void 0
+      });
+      const payload = this.parseResponse(completion);
+      if (completion.toolCalls?.length) {
+        this.conversation.addMessage({
+          role: "assistant",
+          content: completion.content || ""
+        });
+      } else {
+        this.conversation.addMessage({ role: "assistant", content: completion.content });
+      }
+      if (payload.thought) {
+        console.log(chalk10.gray(`[${this.name}] ${payload.thought}`));
+      }
+      if (payload.toolCalls && payload.toolCalls.length > 0) {
+        const results = await this.toolManager.execute(payload.toolCalls);
+        for (let j = 0; j < results.length; j++) {
+          const result = results[j];
+          const toolCall = completion.toolCalls?.[j];
+          const content = result.success ? result.output ?? "(no output)" : result.error ?? "Tool failed";
+          this.conversation.addMessage({
+            role: "tool",
+            name: result.tool,
+            content,
+            tool_call_id: toolCall?.id
+          });
+          if (!result.success) {
+            console.log(chalk10.red(`[${this.name}] Tool ${result.tool} failed: ${content}`));
+          }
+        }
+        continue;
+      }
+      const response = payload.finalResponse ?? payload.response ?? completion.content;
+      console.log(chalk10.cyan(`[${this.name}] Finished.`));
+      return response;
+    }
+    return `[${this.name}] Failed to complete task within ${maxIterations} iterations.`;
+  }
+  /**
+   * Parse LLM response, preferring native tool calls over JSON parsing
+   */
+  parseResponse(completion) {
+    if (completion.toolCalls && completion.toolCalls.length > 0) {
+      return {
+        thought: completion.content || void 0,
+        toolCalls: completion.toolCalls.map((tc) => ({
+          tool: tc.function.name,
+          args: this.safeParseJson(tc.function.arguments)
+        }))
+      };
+    }
+    return this.parsePayload(completion.content);
+  }
+  /**
+   * Safely parse JSON, returning empty object on failure
    */
   safeParseJson(json) {
     try {
@@ -9227,7 +10309,7 @@ ${result}`;
       }
     });
     const results = await Promise.all(promises);
-    return results.join("\n\n" + chalk10.gray("\u2500".repeat(40)) + "\n\n");
+    return results.join("\n\n" + chalk11.gray("\u2500".repeat(40)) + "\n\n");
   }
   /**
    * Get the current delegation depth
@@ -9326,7 +10408,7 @@ var ErrorLogger = class {
 // src/feedback/FeedbackManager.ts
 import fs14 from "fs-extra";
 import path14 from "path";
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 import Enquirer from "enquirer";
 
 // src/feedback/FeedbackApiClient.ts
@@ -9616,11 +10698,13 @@ var FeedbackManager = class {
     };
   }
   saveState() {
-    try {
-      fs14.ensureDirSync(this.stateDir);
-      fs14.writeJsonSync(this.statePath, this.state, { spaces: 2 });
-    } catch {
-    }
+    setImmediate(() => {
+      try {
+        fs14.ensureDirSync(this.stateDir);
+        fs14.writeJsonSync(this.statePath, this.state, { spaces: 2 });
+      } catch {
+      }
+    });
   }
   async saveFeedbackResponse(response) {
     try {
@@ -9724,10 +10808,10 @@ var FeedbackManager = class {
     this.state.lastPromptedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.saveState();
     console.log();
-    console.log(chalk11.cyan("\u2501".repeat(50)));
-    console.log(chalk11.cyan.bold("  Quick Feedback"));
-    console.log(chalk11.gray("  Help us improve Autohand (takes 10 seconds)"));
-    console.log(chalk11.cyan("\u2501".repeat(50)));
+    console.log(chalk12.cyan("\u2501".repeat(50)));
+    console.log(chalk12.cyan.bold("  Quick Feedback"));
+    console.log(chalk12.gray("  Help us improve Autohand (takes 10 seconds)"));
+    console.log(chalk12.cyan("\u2501".repeat(50)));
     console.log();
     const safePrompt = async (config) => {
       try {
@@ -9740,19 +10824,56 @@ var FeedbackManager = class {
       }
     };
     try {
-      const npsResult = await safePrompt({
-        type: "select",
+      const { Select } = Enquirer;
+      const ratingChoices = [
+        { name: "5", message: `${chalk12.green("5")} - Excellent` },
+        { name: "4", message: `${chalk12.green("4")} - Good` },
+        { name: "3", message: `${chalk12.yellow("3")} - Okay` },
+        { name: "2", message: `${chalk12.red("2")} - Poor` },
+        { name: "1", message: `${chalk12.red("1")} - Very Poor` },
+        { name: "skip", message: `${chalk12.gray("s")} - Skip` }
+      ];
+      const ratingPrompt = new Select({
         name: "score",
-        message: "How would you rate your experience?",
-        choices: [
-          { name: "5", message: `${chalk11.green("5")} - Excellent` },
-          { name: "4", message: `${chalk11.green("4")} - Good` },
-          { name: "3", message: `${chalk11.yellow("3")} - Okay` },
-          { name: "2", message: `${chalk11.red("2")} - Poor` },
-          { name: "1", message: `${chalk11.red("1")} - Very Poor` },
-          { name: "skip", message: `${chalk11.gray("Skip")}` }
-        ]
+        message: "How would you rate your experience? (press 1-5 or s to skip)",
+        choices: ratingChoices
       });
+      const originalKeypress = ratingPrompt.keypress.bind(ratingPrompt);
+      ratingPrompt.keypress = async function(char, key) {
+        if (char >= "1" && char <= "5") {
+          const targetName = char;
+          const index = ratingChoices.findIndex((c) => c.name === targetName);
+          if (index !== -1) {
+            this.index = index;
+            this.selected = this.choices[index];
+            this.value = this.choices[index].name;
+            await this.render();
+            return this.submit();
+          }
+        }
+        if (char === "s" || char === "S") {
+          const index = ratingChoices.findIndex((c) => c.name === "skip");
+          if (index !== -1) {
+            this.index = index;
+            this.selected = this.choices[index];
+            this.value = this.choices[index].name;
+            await this.render();
+            return this.submit();
+          }
+        }
+        return originalKeypress(char, key);
+      };
+      let npsResult = null;
+      try {
+        const score = await ratingPrompt.run();
+        npsResult = { score };
+      } catch (error) {
+        if (error?.code === "ERR_USE_AFTER_CLOSE") {
+          npsResult = null;
+        } else {
+          throw error;
+        }
+      }
       if (!npsResult) {
         this.state.dismissed++;
         this.saveState();
@@ -9761,7 +10882,7 @@ var FeedbackManager = class {
       if (npsResult.score === "skip") {
         this.state.dismissed++;
         this.saveState();
-        console.log(chalk11.gray("\nNo problem! You can always use /feedback later.\n"));
+        console.log(chalk12.gray("\nNo problem! You can always use /feedback later.\n"));
         return false;
       }
       const npsScore = parseInt(npsResult.score, 10);
@@ -9808,11 +10929,11 @@ var FeedbackManager = class {
       this.state.averageNps = this.state.npsScores.reduce((a, b) => a + b, 0) / this.state.npsScores.length;
       this.saveState();
       console.log();
-      console.log(chalk11.green("Thank you for your feedback!"));
+      console.log(chalk12.green("Thank you for your feedback!"));
       if (npsScore >= 4) {
-        console.log(chalk11.gray("Your support helps us build a better tool."));
+        console.log(chalk12.gray("Your support helps us build a better tool."));
       } else {
-        console.log(chalk11.gray("We'll work hard to improve your experience."));
+        console.log(chalk12.gray("We'll work hard to improve your experience."));
       }
       console.log();
       return true;
@@ -9822,7 +10943,7 @@ var FeedbackManager = class {
       }
       this.state.dismissed++;
       this.saveState();
-      console.log(chalk11.gray("\nFeedback skipped.\n"));
+      console.log(chalk12.gray("\nFeedback skipped.\n"));
       return false;
     }
   }
@@ -9834,10 +10955,10 @@ var FeedbackManager = class {
   async quickRating() {
     console.log();
     console.log(
-      chalk11.cyan("Quick rating: ") + chalk11.gray("Press ") + chalk11.bold("1-5") + chalk11.gray(" to rate your experience (or ") + chalk11.bold("Enter") + chalk11.gray(" to skip)")
+      chalk12.cyan("Quick rating: ") + chalk12.gray("Press ") + chalk12.bold("1-5") + chalk12.gray(" to rate your experience (or ") + chalk12.bold("Enter") + chalk12.gray(" to skip)")
     );
     console.log(
-      chalk11.gray("  1=Poor  2=Fair  3=Good  4=Great  5=Excellent")
+      chalk12.gray("  1=Poor  2=Fair  3=Good  4=Great  5=Excellent")
     );
     return new Promise((resolve) => {
       const stdin = process.stdin;
@@ -9869,7 +10990,7 @@ var FeedbackManager = class {
         const num = parseInt(key, 10);
         if (num >= 1 && num <= 5) {
           cleanup();
-          console.log(chalk11.green(` ${num}`));
+          console.log(chalk12.green(` ${num}`));
           this.state.npsScores.push(num);
           this.state.feedbackCount++;
           this.state.lastFeedbackAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -9877,7 +10998,7 @@ var FeedbackManager = class {
           this.hasPromptedThisSession = true;
           this.state.lastPromptedAt = (/* @__PURE__ */ new Date()).toISOString();
           this.saveState();
-          console.log(chalk11.green("Thanks!"));
+          console.log(chalk12.green("Thanks!"));
           console.log();
           resolve(num);
         }
@@ -10796,12 +11917,11 @@ var CommunitySkillsClient = class {
 };
 
 // src/ui/persistentInput.ts
-import chalk13 from "chalk";
-import readline3 from "readline";
+import chalk14 from "chalk";
 import EventEmitter from "events";
 
 // src/ui/terminalRegions.ts
-import chalk12 from "chalk";
+import chalk13 from "chalk";
 var ESC = "\x1B";
 var CSI = `${ESC}[`;
 var TerminalRegions = class {
@@ -10865,15 +11985,15 @@ var TerminalRegions = class {
     this.output.write(`${CSI}s`);
     this.output.write(`${CSI}${height - 2};1H`);
     this.output.write(`${CSI}K`);
-    this.output.write(chalk12.gray("\u2500".repeat(width)));
+    this.output.write(chalk13.gray("\u2500".repeat(width)));
     this.output.write(`${CSI}${height - 1};1H`);
     this.output.write(`${CSI}K`);
-    const queueStatus = queueCount > 0 ? chalk12.cyan(` [${queueCount} queued]`) : "";
+    const queueStatus = queueCount > 0 ? chalk13.cyan(` [${queueCount} queued]`) : "";
     const statusText = status || "type to queue \xB7 Enter to submit";
-    this.output.write(chalk12.gray(statusText) + queueStatus);
+    this.output.write(chalk13.gray(statusText) + queueStatus);
     this.output.write(`${CSI}${height};1H`);
     this.output.write(`${CSI}K`);
-    this.output.write(chalk12.gray("\u203A") + " " + input);
+    this.output.write(chalk13.gray("\u203A") + " " + input);
     this.output.write(`${CSI}u`);
   }
   /**
@@ -10885,7 +12005,7 @@ var TerminalRegions = class {
     this.output.write(`${CSI}s`);
     this.output.write(`${CSI}${height};1H`);
     this.output.write(`${CSI}K`);
-    this.output.write(chalk12.gray("\u203A") + " " + input);
+    this.output.write(chalk13.gray("\u203A") + " " + input);
     this.output.write(`${CSI}u`);
   }
   /**
@@ -10897,8 +12017,8 @@ var TerminalRegions = class {
     this.output.write(`${CSI}s`);
     this.output.write(`${CSI}${height - 1};1H`);
     this.output.write(`${CSI}K`);
-    const queueStatus = queueCount > 0 ? chalk12.cyan(` [${queueCount} queued]`) : "";
-    this.output.write(chalk12.gray(status) + queueStatus);
+    const queueStatus = queueCount > 0 ? chalk13.cyan(` [${queueCount} queued]`) : "";
+    this.output.write(chalk13.gray(status) + queueStatus);
     this.output.write(`${CSI}u`);
   }
   /**
@@ -11019,7 +12139,7 @@ var PersistentInput = class extends EventEmitter {
     this.currentInput = "";
     this.isPaused = false;
     if (this.silentMode) {
-      readline3.emitKeypressEvents(this.input);
+      safeEmitKeypressEvents(this.input);
       const supportsRaw = typeof this.input.setRawMode === "function";
       const wasRaw = this.input.isRaw;
       if (!wasRaw && supportsRaw) {
@@ -11030,7 +12150,7 @@ var PersistentInput = class extends EventEmitter {
       this.input.on("keypress", this.handleKeypress);
     } else {
       this.regions.enable();
-      readline3.emitKeypressEvents(this.input);
+      safeEmitKeypressEvents(this.input);
       const supportsRaw = typeof this.input.setRawMode === "function";
       if (supportsRaw) {
         this.input.setRawMode(true);
@@ -11140,7 +12260,7 @@ var PersistentInput = class extends EventEmitter {
       if (this.silentMode) {
         this.emit("queue-full", this.maxQueueSize);
       } else {
-        this.regions.writeAbove(chalk13.yellow(`
+        this.regions.writeAbove(chalk14.yellow(`
 \u26A0 Queue full (max ${this.maxQueueSize})
 `));
       }
@@ -11152,7 +12272,7 @@ var PersistentInput = class extends EventEmitter {
     });
     const preview = text.length > 40 ? text.slice(0, 37) + "..." : text;
     if (!this.silentMode) {
-      this.regions.writeAbove(chalk13.cyan(`
+      this.regions.writeAbove(chalk14.cyan(`
 \u2713 Queued: "${preview}" (${this.queue.length} pending)
 `));
       this.regions.updateStatus(this.statusLine, this.queue.length);
@@ -11255,7 +12375,7 @@ ${truncatedContent}` : outputLines > 0 ? `
 }
 
 // src/ui/promptCallback.ts
-import enquirer2 from "enquirer";
+import enquirer3 from "enquirer";
 function isExternalCallbackEnabled() {
   return !!process.env.AUTOHAND_PERMISSION_CALLBACK_URL;
 }
@@ -11321,7 +12441,7 @@ async function confirm(message, context) {
     while (process.stdin.read() !== null) {
     }
   }
-  const { Select, Input } = enquirer2;
+  const { Select, Input } = enquirer3;
   const choices = [
     { name: "yes", message: "1. Yes" },
     { name: "no", message: "2. No" },
@@ -11334,24 +12454,30 @@ async function confirm(message, context) {
     initial: 0
   });
   const originalKeypress = prompt.keypress.bind(prompt);
-  prompt.keypress = function(char, key) {
+  prompt.keypress = async function(char, key) {
     if (char === "1" || char === "2" || char === "3") {
       const index = parseInt(char, 10) - 1;
       if (index >= 0 && index < choices.length) {
         this.index = index;
-        this.submit();
-        return;
+        this.selected = this.choices[index];
+        this.value = this.choices[index].name;
+        await this.render();
+        return this.submit();
       }
     }
     if (char === "y" || char === "Y") {
       this.index = 0;
-      this.submit();
-      return;
+      this.selected = this.choices[0];
+      this.value = this.choices[0].name;
+      await this.render();
+      return this.submit();
     }
     if (char === "n" || char === "N") {
       this.index = 1;
-      this.submit();
-      return;
+      this.selected = this.choices[1];
+      this.value = this.choices[1].name;
+      await this.render();
+      return this.submit();
     }
     return originalKeypress(char, key);
   };
@@ -11646,7 +12772,7 @@ var IntentDetector = class {
 
 // src/core/EnvironmentBootstrap.ts
 import fs17 from "fs-extra";
-import { join as join2 } from "path";
+import { join as join4 } from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
 var execAsync = promisify(exec);
@@ -11741,11 +12867,11 @@ var EnvironmentBootstrap = class {
    */
   async detectPackageManager(root) {
     for (const { file, pm } of this.lockfileChecks) {
-      if (await fs17.pathExists(join2(root, file))) {
+      if (await fs17.pathExists(join4(root, file))) {
         return pm;
       }
     }
-    const pkgPath = join2(root, "package.json");
+    const pkgPath = join4(root, "package.json");
     if (await fs17.pathExists(pkgPath)) {
       try {
         const pkg = await fs17.readJson(pkgPath);
@@ -11779,7 +12905,7 @@ var EnvironmentBootstrap = class {
     const step = { name: "Git Sync", status: "running" };
     const start = Date.now();
     try {
-      const isGit = await fs17.pathExists(join2(root, ".git"));
+      const isGit = await fs17.pathExists(join4(root, ".git"));
       if (!isGit) {
         return {
           ...step,
@@ -11859,18 +12985,18 @@ var EnvironmentBootstrap = class {
     const start = Date.now();
     const details = [];
     try {
-      const nvmrcPath = join2(root, ".nvmrc");
+      const nvmrcPath = join4(root, ".nvmrc");
       const nvmrcExists = await fs17.pathExists(nvmrcPath);
-      const nodeVersionPath = join2(root, ".node-version");
+      const nodeVersionPath = join4(root, ".node-version");
       const nodeVersionExists = await fs17.pathExists(nodeVersionPath);
       if (nvmrcExists || nodeVersionExists) {
         details.push("Node version file found");
       }
-      const toolVersionsPath = join2(root, ".tool-versions");
+      const toolVersionsPath = join4(root, ".tool-versions");
       if (await fs17.pathExists(toolVersionsPath)) {
         details.push(".tool-versions found");
       }
-      const rustToolchainPath = join2(root, "rust-toolchain.toml");
+      const rustToolchainPath = join4(root, "rust-toolchain.toml");
       if (await fs17.pathExists(rustToolchainPath)) {
         details.push("Rust toolchain found");
       }
@@ -11949,7 +13075,7 @@ var EnvironmentBootstrap = class {
 
 // src/core/CodeQualityPipeline.ts
 import fs18 from "fs-extra";
-import { join as join3 } from "path";
+import { join as join5 } from "path";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync2 = promisify2(exec2);
@@ -12017,7 +13143,7 @@ var CodeQualityPipeline = class {
    * @returns Detected scripts
    */
   async detectScripts(root) {
-    const pkgPath = join3(root, "package.json");
+    const pkgPath = join5(root, "package.json");
     if (!await fs18.pathExists(pkgPath)) {
       return {};
     }
@@ -12184,7 +13310,7 @@ var CodeQualityPipeline = class {
 };
 
 // src/core/agent.ts
-var AutohandAgent = class {
+var AutohandAgent = class _AutohandAgent {
   constructor(llm, files, runtime) {
     this.llm = llm;
     this.files = files;
@@ -12193,6 +13319,8 @@ var AutohandAgent = class {
     this.contextPercentLeft = 100;
     this.toolOutputQueue = Promise.resolve();
     this.workspaceFiles = [];
+    this.workspaceFilesCachedAt = 0;
+    // 5 seconds
     this.isInstructionActive = false;
     this.hasPrintedExplorationHeader = false;
     this.taskStartedAt = null;
@@ -12240,10 +13368,10 @@ var AutohandAgent = class {
       },
       onHookOutput: (result) => {
         if (result.stdout && !result.response) {
-          console.log(chalk14.dim(`[hook:${result.hook.event}] ${result.stdout}`));
+          console.log(chalk15.dim(`[hook:${result.hook.event}] ${result.stdout}`));
         }
         if (result.stderr && !result.blockingError) {
-          console.error(chalk14.yellow(`[hook:${result.hook.event}] ${result.stderr}`));
+          console.error(chalk15.yellow(`[hook:${result.hook.event}] ${result.stderr}`));
         }
       }
     });
@@ -12412,7 +13540,7 @@ var AutohandAgent = class {
         this.inkRenderer.addQueuedInstruction(text);
       } else if (this.runtime.spinner) {
         const originalText = this.runtime.spinner.text;
-        this.runtime.spinner.text = chalk14.cyan(`\u2713 Queued: "${preview}" (${count} pending)`);
+        this.runtime.spinner.text = chalk15.cyan(`\u2713 Queued: "${preview}" (${count} pending)`);
         setTimeout(() => {
           if (this.runtime.spinner) {
             this.runtime.spinner.text = originalText;
@@ -12420,7 +13548,8 @@ var AutohandAgent = class {
         }, 1500);
       }
     });
-    this.slashHandler = new SlashCommandHandler({
+    const sessionMgr = this.sessionManager;
+    const slashContext = {
       promptModelSelection: () => this.promptModelSelection(),
       createAgentsFile: () => this.createAgentsFile(),
       sessionManager: this.sessionManager,
@@ -12438,8 +13567,16 @@ var AutohandAgent = class {
       provider: this.activeProvider,
       config: runtime.config,
       getContextPercentLeft: () => this.contextPercentLeft,
-      getTotalTokensUsed: () => this.totalTokensUsed
-    }, SLASH_COMMANDS);
+      getTotalTokensUsed: () => this.totalTokensUsed,
+      // Share command needs current session - use getter for dynamic access
+      get currentSession() {
+        return sessionMgr.getCurrentSession() ?? void 0;
+      }
+    };
+    this.slashHandler = new SlashCommandHandler(slashContext, SLASH_COMMANDS);
+  }
+  static {
+    this.WORKSPACE_FILES_CACHE_TTL = 5e3;
   }
   async runInteractive() {
     await this.sessionManager.initialize();
@@ -12505,6 +13642,7 @@ var AutohandAgent = class {
       turnDuration,
       tokensUsed: this.sessionTokensUsed
     });
+    this.ensureStdinReady();
     if (this.runtime.config.ui?.terminalBell !== false) {
       process.stdout.write("\x07");
     }
@@ -12516,6 +13654,7 @@ var AutohandAgent = class {
       sessionEndReason: "exit",
       duration: Date.now() - this.sessionStartedAt
     });
+    this.ensureStdinReady();
     await this.telemetryManager.endSession("completed");
   }
   /**
@@ -12525,17 +13664,17 @@ var AutohandAgent = class {
     const info = getAutoCommitInfo(this.runtime.workspaceRoot);
     if (!info.canCommit) {
       if (info.error !== "No changes to commit") {
-        console.log(chalk14.yellow(`
+        console.log(chalk15.yellow(`
 \u26A0 Cannot auto-commit: ${info.error}`));
       }
       return;
     }
-    console.log(chalk14.cyan("\n\u{1F9E0} Auto-commit: Changes detected"));
+    console.log(chalk15.cyan("\n\u{1F9E0} Auto-commit: Changes detected"));
     info.filesChanged.slice(0, 5).forEach((file) => {
-      console.log(chalk14.gray(`   ${file}`));
+      console.log(chalk15.gray(`   ${file}`));
     });
     if (info.filesChanged.length > 5) {
-      console.log(chalk14.gray(`   ... and ${info.filesChanged.length - 5} more files`));
+      console.log(chalk15.gray(`   ... and ${info.filesChanged.length - 5} more files`));
     }
     const autoCommitPrompt = `You have uncommitted changes in the repository. Please perform the following steps:
 
@@ -12557,11 +13696,11 @@ Diff summary:
 ${info.diffSummary || "Use git diff to see changes"}
 
 If lint or tests fail, report the issues but do NOT commit.`;
-    console.log(chalk14.cyan("\n\u{1F504} Running lint, test, and generating commit message...\n"));
+    console.log(chalk15.cyan("\n\u{1F504} Running lint, test, and generating commit message...\n"));
     try {
       await this.runInstruction(autoCommitPrompt);
     } catch (error) {
-      console.log(chalk14.red(`
+      console.log(chalk15.red(`
 \u2717 Auto-commit failed: ${error.message}`));
     }
   }
@@ -12602,7 +13741,7 @@ If lint or tests fail, report the issues but do NOT commit.`;
       }
       await this.injectProjectKnowledge();
       this.updateContextUsage(this.conversation.history());
-      console.log(chalk14.cyan(`
+      console.log(chalk15.cyan(`
 \u{1F4C2} Resumed session ${sessionId}`));
       await this.telemetryManager.startSession(
         sessionId,
@@ -12611,7 +13750,7 @@ If lint or tests fail, report the issues but do NOT commit.`;
       );
       await this.runInteractiveLoop();
     } catch (error) {
-      console.error(chalk14.red(`Failed to resume session: ${error.message}`));
+      console.error(chalk15.red(`Failed to resume session: ${error.message}`));
       await this.telemetryManager.trackError({
         type: "session_resume_failed",
         message: error.message,
@@ -12630,31 +13769,31 @@ If lint or tests fail, report the issues but do NOT commit.`;
         if (this.pendingInkInstructions.length > 0) {
           instruction = this.pendingInkInstructions.shift() ?? null;
           if (instruction) {
-            console.log(chalk14.cyan(`
+            console.log(chalk15.cyan(`
 \u25B6 Processing queued request: "${instruction.slice(0, 50)}${instruction.length > 50 ? "..." : ""}"`));
             const remaining = this.pendingInkInstructions.length;
             if (remaining > 0) {
-              console.log(chalk14.gray(`  ${remaining} more request(s) queued`));
+              console.log(chalk15.gray(`  ${remaining} more request(s) queued`));
             }
           }
         } else if (this.inkRenderer?.hasQueuedInstructions()) {
           instruction = this.inkRenderer.dequeueInstruction() ?? null;
           if (instruction) {
-            console.log(chalk14.cyan(`
+            console.log(chalk15.cyan(`
 \u25B6 Processing queued request: "${instruction.slice(0, 50)}${instruction.length > 50 ? "..." : ""}"`));
             const remaining = this.inkRenderer.getQueueCount();
             if (remaining > 0) {
-              console.log(chalk14.gray(`  ${remaining} more request(s) queued`));
+              console.log(chalk15.gray(`  ${remaining} more request(s) queued`));
             }
           }
         } else if (this.persistentInput.hasQueued()) {
           const queued = this.persistentInput.dequeue();
           if (queued) {
             instruction = queued.text;
-            console.log(chalk14.cyan(`
+            console.log(chalk15.cyan(`
 \u25B6 Processing queued request: "${instruction.slice(0, 50)}${instruction.length > 50 ? "..." : ""}"`));
             if (this.persistentInput.hasQueued()) {
-              console.log(chalk14.gray(`  ${this.persistentInput.getQueueLength()} more request(s) queued`));
+              console.log(chalk15.gray(`  ${this.persistentInput.getQueueLength()} more request(s) queued`));
             }
           }
         }
@@ -12690,6 +13829,7 @@ If lint or tests fail, report the issues but do NOT commit.`;
           turnDuration,
           tokensUsed: this.sessionTokensUsed
         });
+        this.ensureStdinReady();
         if (this.runtime.config.ui?.terminalBell !== false) {
           process.stdout.write("\x07");
         }
@@ -12730,9 +13870,9 @@ If lint or tests fail, report the issues but do NOT commit.`;
           await session.save();
         }
         const errorMessage = error.message || "Unknown error occurred";
-        console.error(chalk14.red("\n\u274C An error occurred:"));
-        console.error(chalk14.red(errorMessage));
-        console.error(chalk14.gray(`Error logged to: ${this.errorLogger.getLogPath()}
+        console.error(chalk15.red("\n\u274C An error occurred:"));
+        console.error(chalk15.red(errorMessage));
+        console.error(chalk15.gray(`Error logged to: ${this.errorLogger.getLogPath()}
 `));
         continue;
       }
@@ -12760,7 +13900,7 @@ If lint or tests fail, report the issues but do NOT commit.`;
       return null;
     }
     if (normalized === "/") {
-      console.log(chalk14.gray("Type a slash command name (e.g. /diff) and press Enter."));
+      console.log(chalk15.gray("Type a slash command name (e.g. /diff) and press Enter."));
       return null;
     }
     const looksLikeFilePath = (text) => {
@@ -12797,12 +13937,12 @@ If lint or tests fail, report the issues but do NOT commit.`;
   }
   async handleMemoryStore(content) {
     if (!content) {
-      console.log(chalk14.gray("Usage: # <text to remember>"));
-      console.log(chalk14.gray("Example: # Always use TypeScript strict mode"));
+      console.log(chalk15.gray("Usage: # <text to remember>"));
+      console.log(chalk15.gray("Example: # Always use TypeScript strict mode"));
       return;
     }
     try {
-      const { Select } = enquirer3;
+      const { Select } = enquirer4;
       const prompt = new Select({
         name: "level",
         message: "Where should this memory be stored?",
@@ -12815,9 +13955,9 @@ If lint or tests fail, report the issues but do NOT commit.`;
       const similar = await this.memoryManager.findSimilar(content, level);
       if (similar && similar.score >= 0.6) {
         console.log();
-        console.log(chalk14.yellow("Found similar existing memory:"));
-        console.log(chalk14.gray(`  "${similar.entry.content}"`));
-        const { Confirm } = enquirer3;
+        console.log(chalk15.yellow("Found similar existing memory:"));
+        console.log(chalk15.gray(`  "${similar.entry.content}"`));
+        const { Confirm } = enquirer4;
         const confirmPrompt = new Confirm({
           name: "update",
           message: "Update the existing memory instead of creating a new one?"
@@ -12825,27 +13965,31 @@ If lint or tests fail, report the issues but do NOT commit.`;
         const shouldUpdate = await confirmPrompt.run();
         if (shouldUpdate) {
           await this.memoryManager.updateMemory(similar.entry.id, content, level);
-          console.log(chalk14.green("Memory updated."));
+          console.log(chalk15.green("Memory updated."));
           return;
         }
       }
       await this.memoryManager.store(content, level);
-      console.log(chalk14.green(`Memory saved to ${level} level.`));
+      console.log(chalk15.green(`Memory saved to ${level} level.`));
     } catch (error) {
       if (error.isCanceled) {
         return;
       }
-      console.error(chalk14.red("Failed to store memory:"), error.message);
+      console.error(chalk15.red("Failed to store memory:"), error.message);
     }
   }
   async listWorkspaceFiles() {
     const entries = await fs19.readdir(this.runtime.workspaceRoot);
     const sorted = entries.sort((a, b) => a.localeCompare(b));
-    console.log("\n" + chalk14.cyan("Workspace files:"));
+    console.log("\n" + chalk15.cyan("Workspace files:"));
     console.log(sorted.map((entry) => ` - ${entry}`).join("\n"));
     console.log();
   }
   async collectWorkspaceFiles() {
+    const now = Date.now();
+    if (this.workspaceFiles.length > 0 && now - this.workspaceFilesCachedAt < _AutohandAgent.WORKSPACE_FILES_CACHE_TTL) {
+      return this.workspaceFiles;
+    }
     const git = spawnSync5("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
       cwd: this.runtime.workspaceRoot,
       encoding: "utf8"
@@ -12858,9 +14002,11 @@ If lint or tests fail, report the issues but do NOT commit.`;
           files.push(file);
         }
       });
+      this.workspaceFilesCachedAt = now;
       return files;
     }
     await this.walkWorkspace(this.runtime.workspaceRoot, files);
+    this.workspaceFilesCachedAt = now;
     return files;
   }
   async walkWorkspace(current, acc) {
@@ -12898,7 +14044,7 @@ If lint or tests fail, report the issues but do NOT commit.`;
       encoding: "utf8"
     });
     if (status.status === 0 && status.stdout) {
-      console.log("\n" + chalk14.cyan("Git status:"));
+      console.log("\n" + chalk15.cyan("Git status:"));
       console.log(status.stdout.trim() + "\n");
     }
     const diff = spawnSync5("git", ["diff", "--color=always"], {
@@ -12906,18 +14052,18 @@ If lint or tests fail, report the issues but do NOT commit.`;
       encoding: "utf8"
     });
     if (diff.status === 0) {
-      console.log(chalk14.cyan("Git diff:"));
-      console.log(diff.stdout || chalk14.gray("No diff."));
+      console.log(chalk15.cyan("Git diff:"));
+      console.log(diff.stdout || chalk15.gray("No diff."));
     } else {
-      console.log(chalk14.yellow("Unable to compute git diff. Is this a git repository?"));
+      console.log(chalk15.yellow("Unable to compute git diff. Is this a git repository?"));
     }
   }
   async undoLastMutation() {
     try {
       await this.files.undoLast();
-      console.log(chalk14.green("Reverted last mutation."));
+      console.log(chalk15.green("Reverted last mutation."));
     } catch (error) {
-      console.log(chalk14.yellow(error.message));
+      console.log(chalk15.yellow(error.message));
     }
   }
   async promptModelSelection() {
@@ -12925,16 +14071,16 @@ If lint or tests fail, report the issues but do NOT commit.`;
       const allProviders = ProviderFactory.getProviderNames();
       const providerChoices = allProviders.map((name) => {
         const isConfigured = this.isProviderConfigured(name);
-        const indicator = isConfigured ? chalk14.green("\u25CF") : chalk14.red("\u25CB");
-        const current = name === this.activeProvider ? chalk14.cyan(" (current)") : "";
-        const siliconNote = name === "mlx" ? chalk14.gray(" (Apple Silicon)") : "";
+        const indicator = isConfigured ? chalk15.green("\u25CF") : chalk15.red("\u25CB");
+        const current = name === this.activeProvider ? chalk15.cyan(" (current)") : "";
+        const siliconNote = name === "mlx" ? chalk15.gray(" (Apple Silicon)") : "";
         return {
           name,
           message: `${indicator} ${name}${current}${siliconNote}`,
           value: name
         };
       });
-      const providerAnswer = await enquirer3.prompt([
+      const providerAnswer = await enquirer4.prompt([
         {
           type: "select",
           name: "provider",
@@ -12944,7 +14090,7 @@ If lint or tests fail, report the issues but do NOT commit.`;
       ]);
       const selectedProvider = providerAnswer.provider;
       if (!this.isProviderConfigured(selectedProvider)) {
-        console.log(chalk14.yellow(`
+        console.log(chalk15.yellow(`
 ${selectedProvider} is not configured yet. Let's set it up!
 `));
         await this.configureProvider(selectedProvider);
@@ -12953,7 +14099,7 @@ ${selectedProvider} is not configured yet. Let's set it up!
       await this.changeProviderModel(selectedProvider);
     } catch (error) {
       if (error.name === "ExitPromptError" || error.message?.includes("canceled")) {
-        console.log(chalk14.gray("\nConfiguration cancelled."));
+        console.log(chalk15.gray("\nConfiguration cancelled."));
         return;
       }
       throw error;
@@ -12988,9 +14134,9 @@ ${selectedProvider} is not configured yet. Let's set it up!
   }
   async configureOpenRouter() {
     try {
-      console.log(chalk14.cyan("OpenRouter Configuration"));
-      console.log(chalk14.gray("Get your API key at: https://openrouter.ai/keys\n"));
-      const answers = await enquirer3.prompt([
+      console.log(chalk15.cyan("OpenRouter Configuration"));
+      console.log(chalk15.gray("Get your API key at: https://openrouter.ai/keys\n"));
+      const answers = await enquirer4.prompt([
         {
           type: "password",
           name: "apiKey",
@@ -13012,10 +14158,10 @@ ${selectedProvider} is not configured yet. Let's set it up!
       this.runtime.options.model = answers.model;
       await saveConfig(this.runtime.config);
       this.resetLlmClient("openrouter", answers.model);
-      console.log(chalk14.green("\n\u2713 OpenRouter configured successfully!"));
+      console.log(chalk15.green("\n\u2713 OpenRouter configured successfully!"));
     } catch (error) {
       if (error.name === "ExitPromptError" || error.message?.includes("canceled")) {
-        console.log(chalk14.gray("\nConfiguration cancelled."));
+        console.log(chalk15.gray("\nConfiguration cancelled."));
         return;
       }
       throw error;
@@ -13023,8 +14169,8 @@ ${selectedProvider} is not configured yet. Let's set it up!
   }
   async configureOllama() {
     try {
-      console.log(chalk14.cyan("Ollama Configuration"));
-      console.log(chalk14.gray("Make sure Ollama is running: ollama serve\n"));
+      console.log(chalk15.cyan("Ollama Configuration"));
+      console.log(chalk15.gray("Make sure Ollama is running: ollama serve\n"));
       const ollamaUrl = "http://localhost:11434";
       let availableModels = [];
       try {
@@ -13034,13 +14180,13 @@ ${selectedProvider} is not configured yet. Let's set it up!
           availableModels = data.models?.map((m) => m.name) || [];
         }
       } catch {
-        console.log(chalk14.yellow("\u26A0 Could not connect to Ollama. Make sure it's running.\n"));
+        console.log(chalk15.yellow("\u26A0 Could not connect to Ollama. Make sure it's running.\n"));
       }
       let modelAnswer;
       if (availableModels.length > 0) {
-        console.log(chalk14.green(`Found ${availableModels.length} model(s)
+        console.log(chalk15.green(`Found ${availableModels.length} model(s)
 `));
-        modelAnswer = await enquirer3.prompt([
+        modelAnswer = await enquirer4.prompt([
           {
             type: "select",
             name: "model",
@@ -13049,7 +14195,7 @@ ${selectedProvider} is not configured yet. Let's set it up!
           }
         ]);
       } else {
-        modelAnswer = await enquirer3.prompt([
+        modelAnswer = await enquirer4.prompt([
           {
             type: "input",
             name: "model",
@@ -13066,10 +14212,10 @@ ${selectedProvider} is not configured yet. Let's set it up!
       this.runtime.options.model = modelAnswer.model;
       await saveConfig(this.runtime.config);
       this.resetLlmClient("ollama", modelAnswer.model);
-      console.log(chalk14.green("\n\u2713 Ollama configured successfully!"));
+      console.log(chalk15.green("\n\u2713 Ollama configured successfully!"));
     } catch (error) {
       if (error.name === "ExitPromptError" || error.message?.includes("canceled")) {
-        console.log(chalk14.gray("\nConfiguration cancelled."));
+        console.log(chalk15.gray("\nConfiguration cancelled."));
         return;
       }
       throw error;
@@ -13077,9 +14223,9 @@ ${selectedProvider} is not configured yet. Let's set it up!
   }
   async configureLlamaCpp() {
     try {
-      console.log(chalk14.cyan("llama.cpp Configuration"));
-      console.log(chalk14.gray("Make sure llama.cpp server is running: ./server -m model.gguf\n"));
-      const answers = await enquirer3.prompt([
+      console.log(chalk15.cyan("llama.cpp Configuration"));
+      console.log(chalk15.gray("Make sure llama.cpp server is running: ./server -m model.gguf\n"));
+      const answers = await enquirer4.prompt([
         {
           type: "input",
           name: "port",
@@ -13102,10 +14248,10 @@ ${selectedProvider} is not configured yet. Let's set it up!
       this.runtime.options.model = answers.model;
       await saveConfig(this.runtime.config);
       this.resetLlmClient("llamacpp", answers.model);
-      console.log(chalk14.green("\n\u2713 llama.cpp configured successfully!"));
+      console.log(chalk15.green("\n\u2713 llama.cpp configured successfully!"));
     } catch (error) {
       if (error.name === "ExitPromptError" || error.message?.includes("canceled")) {
-        console.log(chalk14.gray("\nConfiguration cancelled."));
+        console.log(chalk15.gray("\nConfiguration cancelled."));
         return;
       }
       throw error;
@@ -13113,8 +14259,8 @@ ${selectedProvider} is not configured yet. Let's set it up!
   }
   async configureOpenAI() {
     try {
-      console.log(chalk14.cyan("OpenAI Configuration"));
-      console.log(chalk14.gray("Get your API key at: https://platform.openai.com/api-keys\n"));
+      console.log(chalk15.cyan("OpenAI Configuration"));
+      console.log(chalk15.gray("Get your API key at: https://platform.openai.com/api-keys\n"));
       const modelChoices = [
         "gpt-4o",
         "gpt-4o-mini",
@@ -13122,7 +14268,7 @@ ${selectedProvider} is not configured yet. Let's set it up!
         "gpt-4",
         "gpt-3.5-turbo"
       ];
-      const answers = await enquirer3.prompt([
+      const answers = await enquirer4.prompt([
         {
           type: "password",
           name: "apiKey",
@@ -13144,10 +14290,10 @@ ${selectedProvider} is not configured yet. Let's set it up!
       this.runtime.options.model = answers.model;
       await saveConfig(this.runtime.config);
       this.resetLlmClient("openai", answers.model);
-      console.log(chalk14.green("\n\u2713 OpenAI configured successfully!"));
+      console.log(chalk15.green("\n\u2713 OpenAI configured successfully!"));
     } catch (error) {
       if (error.name === "ExitPromptError" || error.message?.includes("canceled")) {
-        console.log(chalk14.gray("\nConfiguration cancelled."));
+        console.log(chalk15.gray("\nConfiguration cancelled."));
         return;
       }
       throw error;
@@ -13155,9 +14301,9 @@ ${selectedProvider} is not configured yet. Let's set it up!
   }
   async configureMLX() {
     try {
-      console.log(chalk14.cyan("MLX Configuration (Apple Silicon)"));
-      console.log(chalk14.gray("MLX provides local LLM inference optimized for Apple Silicon."));
-      console.log(chalk14.gray("Make sure mlx-lm server is running: mlx_lm.server --model <model-name>\n"));
+      console.log(chalk15.cyan("MLX Configuration (Apple Silicon)"));
+      console.log(chalk15.gray("MLX provides local LLM inference optimized for Apple Silicon."));
+      console.log(chalk15.gray("Make sure mlx-lm server is running: mlx_lm.server --model <model-name>\n"));
       const mlxUrl = "http://localhost:8080";
       let availableModels = [];
       try {
@@ -13167,11 +14313,11 @@ ${selectedProvider} is not configured yet. Let's set it up!
           availableModels = data.data?.map((m) => m.id) || [];
         }
       } catch {
-        console.log(chalk14.yellow("\u26A0 Could not connect to MLX server. Make sure it's running.\n"));
+        console.log(chalk15.yellow("\u26A0 Could not connect to MLX server. Make sure it's running.\n"));
       }
       let modelAnswer;
       if (availableModels.length > 0) {
-        modelAnswer = await enquirer3.prompt([
+        modelAnswer = await enquirer4.prompt([
           {
             type: "select",
             name: "model",
@@ -13180,7 +14326,7 @@ ${selectedProvider} is not configured yet. Let's set it up!
           }
         ]);
       } else {
-        modelAnswer = await enquirer3.prompt([
+        modelAnswer = await enquirer4.prompt([
           {
             type: "input",
             name: "model",
@@ -13197,10 +14343,10 @@ ${selectedProvider} is not configured yet. Let's set it up!
       this.runtime.options.model = modelAnswer.model;
       await saveConfig(this.runtime.config);
       this.resetLlmClient("mlx", modelAnswer.model);
-      console.log(chalk14.green("\n\u2713 MLX configured successfully!"));
+      console.log(chalk15.green("\n\u2713 MLX configured successfully!"));
     } catch (error) {
       if (error.name === "ExitPromptError" || error.message?.includes("canceled")) {
-        console.log(chalk14.gray("\nConfiguration cancelled."));
+        console.log(chalk15.gray("\nConfiguration cancelled."));
         return;
       }
       throw error;
@@ -13210,6 +14356,10 @@ ${selectedProvider} is not configured yet. Let's set it up!
     try {
       const currentSettings = getProviderConfig(this.runtime.config, provider);
       const currentModel = this.runtime.options.model ?? currentSettings?.model ?? "";
+      if (provider === "openai" || provider === "openrouter") {
+        await this.changeCloudProviderSettings(provider, currentModel, currentSettings);
+        return;
+      }
       if (provider === "ollama" && currentSettings?.baseUrl) {
         try {
           const response = await fetch(`${currentSettings.baseUrl}/api/tags`);
@@ -13217,7 +14367,7 @@ ${selectedProvider} is not configured yet. Let's set it up!
             const data = await response.json();
             const models = data.models?.map((m) => m.name) || [];
             if (models.length > 0) {
-              const answer2 = await enquirer3.prompt([
+              const answer2 = await enquirer4.prompt([
                 {
                   type: "select",
                   name: "model",
@@ -13233,21 +14383,7 @@ ${selectedProvider} is not configured yet. Let's set it up!
         } catch {
         }
       }
-      if (provider === "openai") {
-        const models = ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-4", "gpt-3.5-turbo"];
-        const answer2 = await enquirer3.prompt([
-          {
-            type: "select",
-            name: "model",
-            message: "Select a model",
-            choices: models,
-            initial: Math.max(0, models.indexOf(currentModel))
-          }
-        ]);
-        await this.applyModelChange(provider, answer2.model, currentModel);
-        return;
-      }
-      const answer = await enquirer3.prompt([
+      const answer = await enquirer4.prompt([
         {
           type: "input",
           name: "model",
@@ -13258,15 +14394,174 @@ ${selectedProvider} is not configured yet. Let's set it up!
       await this.applyModelChange(provider, answer.model?.trim(), currentModel);
     } catch (error) {
       if (error.name === "ExitPromptError" || error.message?.includes("canceled")) {
-        console.log(chalk14.gray("\nModel change cancelled."));
+        console.log(chalk15.gray("\nModel change cancelled."));
         return;
       }
       throw error;
     }
   }
+  async changeCloudProviderSettings(provider, currentModel, currentSettings) {
+    const providerName = provider === "openai" ? "OpenAI" : "OpenRouter";
+    const maskedKey = currentSettings?.apiKey ? `...${currentSettings.apiKey.slice(-4)}` : "not set";
+    console.log(chalk15.cyan(`
+${providerName} Settings`));
+    console.log(chalk15.gray(`Current model: ${currentModel || "not set"}`));
+    console.log(chalk15.gray(`Current API key: ${maskedKey}
+`));
+    const { action } = await enquirer4.prompt([
+      {
+        type: "select",
+        name: "action",
+        message: "What would you like to change?",
+        choices: [
+          { name: "model", message: "Change model only" },
+          { name: "apiKey", message: "Change API key only" },
+          { name: "both", message: "Change both model and API key" }
+        ]
+      }
+    ]);
+    let newModel = currentModel;
+    let newApiKey = currentSettings?.apiKey || "";
+    if (action === "apiKey" || action === "both") {
+      const keyUrl = provider === "openai" ? "https://platform.openai.com/api-keys" : "https://openrouter.ai/keys";
+      console.log(chalk15.gray(`
+Get your API key at: ${keyUrl}
+`));
+      const { apiKey } = await enquirer4.prompt([
+        {
+          type: "password",
+          name: "apiKey",
+          message: `Enter your ${providerName} API key`,
+          validate: (val) => {
+            const v = val;
+            if (!v?.trim()) return "API key is required";
+            if (v.length < 10) return "API key seems too short";
+            return true;
+          }
+        }
+      ]);
+      console.log(chalk15.gray("\nValidating API key..."));
+      const validationResult = await this.validateApiKey(provider, apiKey.trim());
+      if (!validationResult.valid) {
+        console.log(chalk15.red(`
+\u2717 ${validationResult.error}`));
+        console.log(chalk15.gray(validationResult.hint || ""));
+        return;
+      }
+      console.log(chalk15.green("\u2713 API key is valid\n"));
+      newApiKey = apiKey.trim();
+    }
+    if (action === "model" || action === "both") {
+      if (provider === "openai") {
+        const models = ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-4", "gpt-3.5-turbo", "o1", "o1-mini"];
+        const { model } = await enquirer4.prompt([
+          {
+            type: "select",
+            name: "model",
+            message: "Select a model",
+            choices: models,
+            initial: Math.max(0, models.indexOf(currentModel))
+          }
+        ]);
+        newModel = model;
+      } else {
+        const { model } = await enquirer4.prompt([
+          {
+            type: "input",
+            name: "model",
+            message: "Enter the model ID",
+            initial: currentModel || "anthropic/claude-sonnet-4-20250514"
+          }
+        ]);
+        newModel = model.trim();
+      }
+    }
+    const baseUrl = provider === "openai" ? "https://api.openai.com/v1" : "https://openrouter.ai/api/v1";
+    this.runtime.config[provider] = {
+      apiKey: newApiKey,
+      baseUrl,
+      model: newModel
+    };
+    this.runtime.config.provider = provider;
+    this.runtime.options.model = newModel;
+    await saveConfig(this.runtime.config);
+    this.resetLlmClient(provider, newModel);
+    this.contextWindow = getContextWindow(newModel);
+    this.contextPercentLeft = 100;
+    this.emitStatus();
+    console.log(chalk15.green(`
+\u2713 ${providerName} settings updated successfully!`));
+    console.log(chalk15.gray(`  Provider: ${provider}`));
+    console.log(chalk15.gray(`  Model: ${newModel}`));
+  }
+  async validateApiKey(provider, apiKey) {
+    try {
+      const baseUrl = provider === "openai" ? "https://api.openai.com/v1" : "https://openrouter.ai/api/v1";
+      const response = await fetch(`${baseUrl}/models`, {
+        method: "GET",
+        headers: {
+          "Authorization": `Bearer ${apiKey}`,
+          "Content-Type": "application/json",
+          ...provider === "openrouter" && {
+            "HTTP-Referer": "https://autohand.dev",
+            "X-Title": "Autohand CLI"
+          }
+        }
+      });
+      if (response.ok) {
+        return { valid: true };
+      }
+      const status = response.status;
+      let errorData = {};
+      try {
+        errorData = await response.json();
+      } catch {
+      }
+      if (status === 401) {
+        return {
+          valid: false,
+          error: "Invalid API key",
+          hint: provider === "openai" ? "Check that your API key is correct at https://platform.openai.com/api-keys" : "Check that your API key is correct at https://openrouter.ai/keys"
+        };
+      }
+      if (status === 403) {
+        return {
+          valid: false,
+          error: "API key does not have permission",
+          hint: "Your API key may have restricted permissions or your account may need to add a payment method."
+        };
+      }
+      if (status === 429) {
+        return {
+          valid: false,
+          error: "Rate limited or quota exceeded",
+          hint: "You may have exceeded your API quota. Check your usage and billing settings."
+        };
+      }
+      return {
+        valid: false,
+        error: errorData?.error?.message || `API returned status ${status}`,
+        hint: "Please verify your API key and try again."
+      };
+    } catch (error) {
+      const err = error;
+      if (err.message?.includes("fetch") || err.message?.includes("network")) {
+        return {
+          valid: false,
+          error: "Network error - could not reach the API",
+          hint: "Check your internet connection and try again."
+        };
+      }
+      return {
+        valid: false,
+        error: `Validation failed: ${err.message}`,
+        hint: "Please try again or check your network connection."
+      };
+    }
+  }
   async applyModelChange(provider, newModel, currentModel) {
     if (!newModel || newModel === currentModel && provider === this.activeProvider) {
-      console.log(chalk14.gray("Model unchanged."));
+      console.log(chalk15.gray("Model unchanged."));
       return;
     }
     const previousModel = this.runtime.options.model;
@@ -13283,10 +14578,10 @@ ${selectedProvider} is not configured yet. Let's set it up!
       toModel: newModel,
       provider
     });
-    console.log(chalk14.green(`\u2713 Using ${provider} model ${newModel}`));
+    console.log(chalk15.green(`\u2713 Using ${provider} model ${newModel}`));
   }
   async promptApprovalMode() {
-    const answer = await enquirer3.prompt([
+    const answer = await enquirer4.prompt([
       {
         type: "select",
         name: "mode",
@@ -13300,21 +14595,37 @@ ${selectedProvider} is not configured yet. Let's set it up!
     ]);
     this.runtime.options.yes = answer.mode === "prompt";
     console.log(
-      answer.mode === "prompt" ? chalk14.yellow("Auto-confirm enabled. Use responsibly.") : chalk14.green("Manual approvals required before risky writes.")
+      answer.mode === "prompt" ? chalk15.yellow("Auto-confirm enabled. Use responsibly.") : chalk15.green("Manual approvals required before risky writes.")
     );
   }
   async createAgentsFile() {
     const target = path18.join(this.runtime.workspaceRoot, "AGENTS.md");
     if (await fs19.pathExists(target)) {
-      console.log(chalk14.gray("AGENTS.md already exists in this workspace."));
+      console.log(chalk15.gray("AGENTS.md already exists in this workspace."));
       return;
     }
-    const template = `# Project Autopilot
-
-Describe how Autohand should work in this repo. Include framework commands, testing requirements, and any constraints.
-`;
-    await fs19.writeFile(target, template, "utf8");
-    console.log(chalk14.green("Created AGENTS.md template. Customize it to guide the agent."));
+    console.log(chalk15.gray("Analyzing project structure..."));
+    const analyzer = new ProjectAnalyzer(this.runtime.workspaceRoot);
+    const projectInfo = await analyzer.analyze();
+    if (Object.keys(projectInfo).length > 0) {
+      console.log(chalk15.gray("Detected:"));
+      if (projectInfo.language) {
+        console.log(chalk15.white(`  - Language: ${projectInfo.language}`));
+      }
+      if (projectInfo.framework) {
+        console.log(chalk15.white(`  - Framework: ${projectInfo.framework}`));
+      }
+      if (projectInfo.packageManager) {
+        console.log(chalk15.white(`  - Package manager: ${projectInfo.packageManager}`));
+      }
+      if (projectInfo.testFramework) {
+        console.log(chalk15.white(`  - Test framework: ${projectInfo.testFramework}`));
+      }
+    }
+    const generator = new AgentsGenerator();
+    const content = generator.generateContent(projectInfo);
+    await fs19.writeFile(target, content, "utf8");
+    console.log(chalk15.green("Created AGENTS.md based on your project. Customize it to guide the agent."));
   }
   /**
    * Detect if instruction is simple chat that doesn't need tools
@@ -13356,7 +14667,7 @@ Describe how Autohand should work in this repo. Include framework commands, test
       return true;
     } catch (error) {
       if (error instanceof Error) {
-        console.error(chalk14.red(error.message));
+        console.error(chalk15.red(error.message));
       }
       return false;
     } finally {
@@ -13375,7 +14686,7 @@ Describe how Autohand should work in this repo. Include framework commands, test
     if (intentResult.intent === "implementation") {
       const bootstrapResult = await this.runEnvironmentBootstrap();
       if (!bootstrapResult.success) {
-        console.log(chalk14.red("\n[BLOCKED] Environment setup failed. Fix issues before proceeding."));
+        console.log(chalk15.red("\n[BLOCKED] Environment setup failed. Fix issues before proceeding."));
         this.isInstructionActive = false;
         return false;
       }
@@ -13388,7 +14699,7 @@ Describe how Autohand should work in this repo. Include framework commands, test
         canceledByUser = true;
         this.stopStatusUpdates();
         this.stopUI();
-        console.log("\n" + chalk14.yellow("Request canceled by user (ESC)."));
+        console.log("\n" + chalk15.yellow("Request canceled by user (ESC)."));
       }
     });
     const cleanupEsc = this.useInkRenderer ? () => {
@@ -13397,7 +14708,7 @@ Describe how Autohand should work in this repo. Include framework commands, test
         canceledByUser = true;
         this.stopStatusUpdates();
         this.stopUI();
-        console.log("\n" + chalk14.yellow("Request canceled by user (ESC)."));
+        console.log("\n" + chalk15.yellow("Request canceled by user (ESC)."));
       }
     }, true);
     const stopPreparation = this.startPreparationStatus(instruction);
@@ -13419,7 +14730,7 @@ Describe how Autohand should work in this repo. Include framework commands, test
       }
       if (error instanceof ProviderNotConfiguredError) {
         this.cleanupUI();
-        console.log(chalk14.yellow(`
+        console.log(chalk15.yellow(`
 No provider is configured yet. Let's set one up!
 `));
         await this.promptModelSelection();
@@ -13431,9 +14742,9 @@ No provider is configured yet. Let's set one up!
       if (this.isRetryableSessionError(err) && this.sessionRetryCount < maxRetries) {
         this.sessionRetryCount++;
         await this.submitSessionFailureBugReport(err, this.sessionRetryCount, maxRetries);
-        console.log(chalk14.yellow(`
+        console.log(chalk15.yellow(`
 \u26A0 Session encountered an error: ${err.message}`));
-        console.log(chalk14.cyan(`  Attempting recovery (${this.sessionRetryCount}/${maxRetries})...`));
+        console.log(chalk15.cyan(`  Attempting recovery (${this.sessionRetryCount}/${maxRetries})...`));
         const delay = baseDelay * Math.pow(1.5, this.sessionRetryCount - 1);
         await this.sleep(delay);
         this.injectContinuationMessage(err, this.sessionRetryCount);
@@ -13456,7 +14767,7 @@ No provider is configured yet. Let's set one up!
       const errorMessage = error instanceof Error ? error.message : String(error);
       this.emitOutput({ type: "error", content: errorMessage });
       if (error instanceof Error) {
-        console.error(chalk14.red(error.message));
+        console.error(chalk15.red(error.message));
       } else {
         console.error(error);
       }
@@ -13470,7 +14781,7 @@ No provider is configured yet. Let's set one up!
         const tokens = this.formatTokens(this.totalTokensUsed);
         const queueCount = this.pendingInkInstructions.length + (this.inkRenderer?.getQueueCount() ?? 0) + this.persistentInput.getQueueLength();
         const queueStatus = queueCount > 0 ? ` \xB7 ${queueCount} queued` : "";
-        console.log(chalk14.gray(`
+        console.log(chalk15.gray(`
 Completed in ${elapsed} \xB7 ${tokens} used${queueStatus}`));
       }
       this.sessionTokensUsed += this.totalTokensUsed;
@@ -13546,7 +14857,7 @@ Completed in ${elapsed} \xB7 ${tokens} used${queueStatus}`));
       duration: sessionDuration
     });
     if (!session) {
-      console.log(chalk14.gray("Ending Autohand session."));
+      console.log(chalk15.gray("Ending Autohand session."));
       await this.telemetryManager.shutdown();
       return;
     }
@@ -13566,12 +14877,12 @@ Completed in ${elapsed} \xB7 ${tokens} used${queueStatus}`));
     await this.telemetryManager.endSession("completed");
     await this.telemetryManager.shutdown();
     await this.sessionManager.closeSession(summary);
-    console.log(chalk14.gray("\nEnding Autohand session.\n"));
-    console.log(chalk14.cyan(`\u{1F4BE} Session saved: ${session.metadata.sessionId}`));
+    console.log(chalk15.gray("\nEnding Autohand session.\n"));
+    console.log(chalk15.cyan(`\u{1F4BE} Session saved: ${session.metadata.sessionId}`));
     if (syncResult.success) {
-      console.log(chalk14.gray(`   Synced to cloud: ${syncResult.id}`));
+      console.log(chalk15.gray(`   Synced to cloud: ${syncResult.id}`));
     }
-    console.log(chalk14.gray(`   Resume with: autohand resume ${session.metadata.sessionId}
+    console.log(chalk15.gray(`   Resume with: autohand resume ${session.metadata.sessionId}
 `));
   }
   async runReactLoop(abortController) {
@@ -13599,7 +14910,7 @@ Completed in ${elapsed} \xB7 ${tokens} used${queueStatus}`));
       );
       if (contextUsage.isCritical) {
         this.runtime.spinner?.stop();
-        console.log(chalk14.yellow("\n\u26A0 Context at critical level, auto-cropping old messages..."));
+        console.log(chalk15.yellow("\n\u26A0 Context at critical level, auto-cropping old messages..."));
         const targetTokens = Math.floor(contextUsage.contextWindow * 0.7);
         const tokensToRemove = contextUsage.totalTokens - targetTokens;
         const avgMessageTokens = 200;
@@ -13612,12 +14923,12 @@ Completed in ${elapsed} \xB7 ${tokens} used${queueStatus}`));
 Summary of removed content:
 ${summary}`
           );
-          console.log(chalk14.gray(`   Removed ${removed.length} messages to free up context space`));
-          console.log(chalk14.gray(`   Summary preserved in context`));
+          console.log(chalk15.gray(`   Removed ${removed.length} messages to free up context space`));
+          console.log(chalk15.gray(`   Summary preserved in context`));
         }
         this.updateContextUsage(this.conversation.history(), tools);
       } else if (contextUsage.isWarning && iteration === 0) {
-        console.log(chalk14.yellow(`
+        console.log(chalk15.yellow(`
 \u26A0 Context at ${Math.round(contextUsage.usagePercent * 100)}% - approaching limit`));
       }
       if (iteration >= 10 && iteration % 10 === 0) {
@@ -13630,6 +14941,7 @@ ${summary}`
 `);
       let completion;
       try {
+        const thinkingLevel = process.env.AUTOHAND_THINKING_LEVEL || "normal";
         completion = await this.llm.complete({
           messages: messagesWithImages,
           temperature: this.runtime.options.temperature ?? 0.2,
@@ -13637,8 +14949,9 @@ ${summary}`
           signal: abortController.signal,
           tools: tools.length > 0 ? tools : void 0,
           toolChoice: tools.length > 0 ? "auto" : void 0,
-          maxTokens: 16e3
+          maxTokens: 16e3,
           // Allow large outputs for file generation
+          thinkingLevel
         });
         if (debugMode) process.stderr.write(`[AGENT DEBUG] LLM returned: content length=${completion.content?.length ?? 0}, toolCalls=${completion.toolCalls?.length ?? 0}
 `);
@@ -13666,12 +14979,12 @@ ${summary}`
       await this.saveAssistantMessage(completion.content, payload.toolCalls);
       this.updateContextUsage(this.conversation.history(), tools);
       if (debugMode) {
-        console.log(chalk14.yellow(`
+        console.log(chalk15.yellow(`
 [DEBUG] Iteration ${iteration}:`));
-        console.log(chalk14.yellow(`  - toolCalls: ${payload.toolCalls?.length ?? 0}`));
-        console.log(chalk14.yellow(`  - thought: ${payload.thought?.slice(0, 100) || "(none)"}`));
-        console.log(chalk14.yellow(`  - finalResponse: ${payload.finalResponse?.slice(0, 100) || "(none)"}`));
-        console.log(chalk14.yellow(`  - raw content: ${completion.content?.slice(0, 200) || "(empty)"}`));
+        console.log(chalk15.yellow(`  - toolCalls: ${payload.toolCalls?.length ?? 0}`));
+        console.log(chalk15.yellow(`  - thought: ${payload.thought?.slice(0, 100) || "(none)"}`));
+        console.log(chalk15.yellow(`  - finalResponse: ${payload.finalResponse?.slice(0, 100) || "(none)"}`));
+        console.log(chalk15.yellow(`  - raw content: ${completion.content?.slice(0, 200) || "(empty)"}`));
       }
       const toolCount = payload.toolCalls?.length ?? 0;
       const hasResponse = Boolean(payload.finalResponse || payload.response || !toolCount && payload.thought);
@@ -13688,7 +15001,7 @@ ${summary}`
       } else {
         if (iteration > 0) {
           const status = toolCount > 0 ? `\u2192 Step ${iteration + 1}: calling ${toolCount} tool(s)` : hasResponse ? `\u2192 Step ${iteration + 1}: preparing response` : `\u2192 Step ${iteration + 1}: thinking...`;
-          console.log(chalk14.gray(status));
+          console.log(chalk15.gray(status));
         }
       }
       if (payload.toolCalls && payload.toolCalls.length > 0) {
@@ -13707,8 +15020,8 @@ ${summary}`
             });
             await this.saveToolMessage("smart_context_cropper", content, call.id);
             this.updateContextUsage(this.conversation.history(), tools);
-            outputLines.push(`${chalk14.cyan("\u2702 smart_context_cropper")}`);
-            outputLines.push(chalk14.gray(content));
+            outputLines.push(`${chalk15.cyan("\u2702 smart_context_cropper")}`);
+            outputLines.push(chalk15.gray(content));
             outputLines.push("");
           }
         }
@@ -13826,6 +15139,7 @@ ${summary}`
       }
       this.stopStatusUpdates();
       let rawResponse;
+      const usedThoughtAsResponse = Boolean(payload.thought) && !payload.finalResponse && !payload.response && !payload.toolCalls?.length;
       if (payload.finalResponse) {
         rawResponse = payload.finalResponse;
       } else if (payload.response) {
@@ -13836,7 +15150,10 @@ ${summary}`
         const cleanedContent = this.cleanupModelResponse(completion.content);
         rawResponse = cleanedContent.startsWith("{") ? "" : cleanedContent;
       }
-      const response = this.cleanupModelResponse(rawResponse.trim());
+      let response = this.cleanupModelResponse(rawResponse.trim());
+      if (!response && usedThoughtAsResponse && payload.thought) {
+        response = payload.thought.trim();
+      }
       if (!response && iteration > 0) {
         const consecutiveEmptyKey = "__consecutiveEmpty";
         const consecutiveEmpty = (this[consecutiveEmptyKey] ?? 0) + 1;
@@ -13844,7 +15161,7 @@ ${summary}`
         if (consecutiveEmpty >= 3) {
           if (debugMode) process.stderr.write(`[AGENT DEBUG] Exiting after 3 consecutive empty responses
 `);
-          console.log(chalk14.yellow("\n\u26A0 Model not providing response after multiple attempts. Showing available context."));
+          console.log(chalk15.yellow("\n\u26A0 Model not providing response after multiple attempts. Showing available context."));
           const fallback = payload.thought || "The model did not provide a clear response. Please try rephrasing your question.";
           if (this.inkRenderer) {
             this.inkRenderer.setWorking(false);
@@ -13863,12 +15180,13 @@ ${summary}`
         continue;
       }
       this.__consecutiveEmpty = 0;
-      if (payload.thought) {
+      const suppressThinking = usedThoughtAsResponse && response.length > 0;
+      if (payload.thought && !suppressThinking) {
         this.emitOutput({ type: "thinking", thought: payload.thought });
       }
       this.emitOutput({ type: "message", content: response });
       if (this.inkRenderer) {
-        if (showThinking && payload.thought) {
+        if (showThinking && payload.thought && !suppressThinking) {
           this.inkRenderer.setThinking(payload.thought);
         }
         this.inkRenderer.setElapsed(this.formatElapsedTime(this.sessionStartedAt));
@@ -13877,8 +15195,8 @@ ${summary}`
         this.inkRenderer.setFinalResponse(response);
       } else {
         this.runtime.spinner?.stop();
-        if (showThinking && payload.thought && !payload.thought.trim().startsWith("{")) {
-          console.log(chalk14.gray(`Thinking: ${payload.thought}`));
+        if (showThinking && payload.thought && !suppressThinking && !payload.thought.trim().startsWith("{")) {
+          console.log(chalk15.gray(`Thinking: ${payload.thought}`));
           console.log();
         }
         console.log(response);
@@ -13887,10 +15205,10 @@ ${summary}`
     }
     this.stopStatusUpdates();
     this.runtime.spinner?.stop();
-    console.log(chalk14.yellow(`
+    console.log(chalk15.yellow(`
 \u26A0 Task exceeded ${maxIterations} tool iterations without completing.`));
-    console.log(chalk14.gray("This usually means the task is too complex for a single turn."));
-    console.log(chalk14.gray("Try breaking it into smaller steps or use /new to start fresh."));
+    console.log(chalk15.gray("This usually means the task is too complex for a single turn."));
+    console.log(chalk15.gray("Try breaking it into smaller steps or use /new to start fresh."));
     throw new Error(`Reached maximum iterations (${maxIterations}) while processing. Try a simpler request or break the task into smaller steps.`);
   }
   /**
@@ -13919,8 +15237,8 @@ ${summary}`
         toolCalls: completion.toolCalls.map((tc) => {
           const rawArgs = tc.function.arguments;
           if (!rawArgs || rawArgs === "{}" || rawArgs === "") {
-            console.error(chalk14.yellow(`\u26A0 Tool "${tc.function.name}" has empty/missing arguments`));
-            console.error(chalk14.gray(`  Raw arguments: "${rawArgs}"`));
+            console.error(chalk15.yellow(`\u26A0 Tool "${tc.function.name}" has empty/missing arguments`));
+            console.error(chalk15.gray(`  Raw arguments: "${rawArgs}"`));
           }
           return {
             id: tc.id,
@@ -13937,7 +15255,7 @@ ${summary}`
    */
   safeParseToolArgs(json) {
     if (!json || typeof json !== "string") {
-      console.error(chalk14.yellow("\u26A0 Tool arguments empty or not a string"));
+      console.error(chalk15.yellow("\u26A0 Tool arguments empty or not a string"));
       return void 0;
     }
     try {
@@ -13945,11 +15263,11 @@ ${summary}`
       if (parsed && typeof parsed === "object") {
         return parsed;
       }
-      console.error(chalk14.yellow(`\u26A0 Tool arguments parsed but not an object: ${typeof parsed}`));
+      console.error(chalk15.yellow(`\u26A0 Tool arguments parsed but not an object: ${typeof parsed}`));
       return void 0;
     } catch (err) {
-      console.error(chalk14.yellow(`\u26A0 Failed to parse tool arguments: ${err instanceof Error ? err.message : String(err)}`));
-      console.error(chalk14.gray(`  Raw JSON: ${json.slice(0, 200)}${json.length > 200 ? "..." : ""}`));
+      console.error(chalk15.yellow(`\u26A0 Failed to parse tool arguments: ${err instanceof Error ? err.message : String(err)}`));
+      console.error(chalk15.gray(`  Raw JSON: ${json.slice(0, 200)}${json.length > 200 ? "..." : ""}`));
       return void 0;
     }
   }
@@ -14465,7 +15783,7 @@ ${toolSignatures}
       const contents = await this.files.readFile(file);
       this.mentionContexts.push({ path: file, contents: this.trimContext(contents) });
     } catch (error) {
-      console.log(chalk14.yellow(`Unable to read ${file} for context: ${error.message}`));
+      console.log(chalk15.yellow(`Unable to read ${file} for context: ${error.message}`));
     }
   }
   trimContext(content) {
@@ -14585,11 +15903,11 @@ ${ctx.contents}`).join("\n\n");
       return;
     }
     if (!this.hasPrintedExplorationHeader) {
-      console.log("\n" + chalk14.bold("* Explored"));
+      console.log("\n" + chalk15.bold("* Explored"));
       this.hasPrintedExplorationHeader = true;
     }
     const label = this.formatExplorationLabel(event.kind);
-    console.log(`  ${chalk14.cyan(label)} ${event.target}`);
+    console.log(`  ${chalk15.cyan(label)} ${event.target}`);
   }
   clearExplorationLog() {
     this.hasPrintedExplorationHeader = false;
@@ -14611,7 +15929,7 @@ ${ctx.contents}`).join("\n\n");
   formatToolResultsBatch(results, charLimit, toolCalls, thought) {
     const lines = [];
     if (thought && !thought.trim().startsWith("{")) {
-      lines.push(chalk14.white(thought));
+      lines.push(chalk15.white(thought));
       lines.push("");
     }
     for (let i = 0; i < results.length; i++) {
@@ -14622,15 +15940,15 @@ ${ctx.contents}`).join("\n\n");
       const command = call?.args?.command;
       const commandArgs = call?.args?.args;
       const display = result.success ? formatToolOutputForDisplay({ tool: result.tool, content, charLimit, filePath, command, commandArgs }) : { output: content, truncated: false, totalChars: content.length };
-      const icon = result.success ? chalk14.green("\u2714") : chalk14.red("\u2716");
-      lines.push(`${icon} ${chalk14.bold(result.tool)}`);
+      const icon = result.success ? chalk15.green("\u2714") : chalk15.red("\u2716");
+      lines.push(`${icon} ${chalk15.bold(result.tool)}`);
       if (content) {
         if (result.success) {
-          lines.push(chalk14.gray(display.output));
+          lines.push(chalk15.gray(display.output));
         } else {
-          lines.push(chalk14.red("\u250C\u2500 Error \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
-          lines.push(chalk14.red("\u2502 ") + chalk14.white(content));
-          lines.push(chalk14.red("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+          lines.push(chalk15.red("\u250C\u2500 Error \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+          lines.push(chalk15.red("\u2502 ") + chalk15.white(content));
+          lines.push(chalk15.red("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
         }
       }
       lines.push("");
@@ -14819,7 +16137,7 @@ ${parts.join("\n")}`
       return () => {
       };
     }
-    readline4.emitKeypressEvents(input);
+    safeEmitKeypressEvents(input);
     const supportsRaw = typeof input.setRawMode === "function";
     const wasRaw = input.isRaw;
     if (!wasRaw && supportsRaw) {
@@ -14843,7 +16161,7 @@ ${parts.join("\n")}`
           controller.abort();
           onCancel();
         } else {
-          console.log(chalk14.gray("Press Ctrl+C again to exit."));
+          console.log(chalk15.gray("Press Ctrl+C again to exit."));
         }
         return;
       }
@@ -14859,7 +16177,7 @@ ${parts.join("\n")}`
             queue.push({ text, timestamp: Date.now() });
             const preview = text.length > 30 ? text.slice(0, 27) + "..." : text;
             if (this.runtime.spinner) {
-              this.runtime.spinner.text = chalk14.cyan(`\u2713 Queued: "${preview}" (${this.persistentInput.getQueueLength()} pending)`);
+              this.runtime.spinner.text = chalk15.cyan(`\u2713 Queued: "${preview}" (${this.persistentInput.getQueueLength()} pending)`);
             }
           }
           return;
@@ -15018,7 +16336,7 @@ ${parts.join("\n")}`
         workspace: this.runtime.workspaceRoot
       });
     } catch (reportError) {
-      console.error(chalk14.gray(`[Debug] Failed to submit bug report: ${reportError.message}`));
+      console.error(chalk15.gray(`[Debug] Failed to submit bug report: ${reportError.message}`));
     }
   }
   /**
@@ -15029,16 +16347,16 @@ ${parts.join("\n")}`
       return;
     }
     if (result.intent === "diagnostic") {
-      console.log(chalk14.blue("[DIAG] Mode: Diagnostic (read-only analysis)"));
+      console.log(chalk15.blue("[DIAG] Mode: Diagnostic (read-only analysis)"));
       if (result.keywords.length > 0) {
         const kws = result.keywords.slice(0, 3).join('", "');
-        console.log(chalk14.gray(`       Detected: "${kws}"`));
+        console.log(chalk15.gray(`       Detected: "${kws}"`));
       }
     } else {
-      console.log(chalk14.yellow("[IMPL] Mode: Implementation"));
+      console.log(chalk15.yellow("[IMPL] Mode: Implementation"));
       if (result.keywords.length > 0) {
         const kws = result.keywords.slice(0, 3).join('", "');
-        console.log(chalk14.gray(`       Detected: "${kws}"`));
+        console.log(chalk15.gray(`       Detected: "${kws}"`));
       }
     }
     console.log();
@@ -15049,22 +16367,22 @@ ${parts.join("\n")}`
   async runEnvironmentBootstrap() {
     const isDebug = process.env.AUTOHAND_DEBUG === "1";
     if (isDebug) {
-      console.log(chalk14.cyan("[BOOTSTRAP] Running environment setup..."));
+      console.log(chalk15.cyan("[BOOTSTRAP] Running environment setup..."));
     }
     const result = await this.environmentBootstrap.run(this.runtime.workspaceRoot);
     for (const step of result.steps) {
-      const status = step.status === "success" ? chalk14.green("[OK]") : step.status === "failed" ? chalk14.red("[FAIL]") : step.status === "skipped" ? chalk14.gray("[SKIP]") : chalk14.gray("[...]");
-      const duration = step.duration ? chalk14.gray(`(${(step.duration / 1e3).toFixed(1)}s)`) : "";
-      const detail = step.detail ? chalk14.gray(` ${step.detail}`) : "";
+      const status = step.status === "success" ? chalk15.green("[OK]") : step.status === "failed" ? chalk15.red("[FAIL]") : step.status === "skipped" ? chalk15.gray("[SKIP]") : chalk15.gray("[...]");
+      const duration = step.duration ? chalk15.gray(`(${(step.duration / 1e3).toFixed(1)}s)`) : "";
+      const detail = step.detail ? chalk15.gray(` ${step.detail}`) : "";
       if (step.status === "failed" || isDebug) {
         console.log(`  ${status} ${step.name.padEnd(14)} ${duration}${detail}`);
       }
       if (step.error) {
-        console.log(chalk14.red(`       Error: ${step.error}`));
+        console.log(chalk15.red(`       Error: ${step.error}`));
       }
     }
     if (result.success && isDebug) {
-      console.log(chalk14.green(`
+      console.log(chalk15.green(`
 [READY] Environment ready (${(result.duration / 1e3).toFixed(1)}s)
 `));
     }
@@ -15074,26 +16392,26 @@ ${parts.join("\n")}`
    * Run code quality pipeline after file modifications
    */
   async runQualityPipeline() {
-    console.log(chalk14.cyan("\n[QUALITY] Running quality checks..."));
+    console.log(chalk15.cyan("\n[QUALITY] Running quality checks..."));
     const result = await this.codeQualityPipeline.run(this.runtime.workspaceRoot);
     for (const check of result.checks) {
-      const status = check.status === "passed" ? chalk14.green("[OK]") : check.status === "failed" ? chalk14.red("[FAIL]") : check.status === "skipped" ? chalk14.gray("[SKIP]") : chalk14.gray("[...]");
-      const duration = check.duration ? chalk14.gray(`(${(check.duration / 1e3).toFixed(1)}s)`) : "";
+      const status = check.status === "passed" ? chalk15.green("[OK]") : check.status === "failed" ? chalk15.red("[FAIL]") : check.status === "skipped" ? chalk15.gray("[SKIP]") : chalk15.gray("[...]");
+      const duration = check.duration ? chalk15.gray(`(${(check.duration / 1e3).toFixed(1)}s)`) : "";
       console.log(`  ${status} ${check.name.padEnd(8)} ${check.command.padEnd(20)} ${duration}`);
       if (check.status === "failed" && check.output) {
         const errorLines = check.output.split("\n").slice(0, 3);
         for (const line of errorLines) {
           if (line.trim()) {
-            console.log(chalk14.red(`       ${line}`));
+            console.log(chalk15.red(`       ${line}`));
           }
         }
       }
     }
     if (result.passed) {
-      console.log(chalk14.green(`
+      console.log(chalk15.green(`
 [PASS] ${result.summary} (${(result.duration / 1e3).toFixed(1)}s)`));
     } else {
-      console.log(chalk14.red(`
+      console.log(chalk15.red(`
 [FAIL] ${result.summary}`));
     }
   }
@@ -15236,7 +16554,7 @@ ${parts.join("\n")}`
     if (!this.runtime.spinner) return;
     const inputPreview = this.queueInput.length > 40 ? "..." + this.queueInput.slice(-37) : this.queueInput;
     const inputLine = `
-${chalk14.gray("\u203A")} ${inputPreview}${chalk14.gray("\u258B")}`;
+${chalk15.gray("\u203A")} ${inputPreview}${chalk15.gray("\u258B")}`;
     const fullText = statusLine + inputLine;
     const cacheKey = `${statusLine}|${inputPreview}`;
     if (cacheKey === this.lastRenderedStatus) return;
@@ -15278,6 +16596,25 @@ ${chalk14.gray("\u203A")} ${inputPreview}${chalk14.gray("\u258B")}`;
     }
     this.emitStatus();
   }
+  /**
+   * Ensure stdin is in a known good state for readline input.
+   * This is called after operations that may interfere with stdin state,
+   * such as hook execution with shell: true.
+   */
+  ensureStdinReady() {
+    const stdin = process.stdin;
+    if (!stdin.isTTY) return;
+    try {
+      if (typeof stdin.setRawMode === "function" && stdin.isRaw) {
+        stdin.setRawMode(false);
+      }
+      if (stdin.isPaused()) {
+        stdin.resume();
+      }
+      safeEmitKeypressEvents(stdin);
+    } catch {
+    }
+  }
   formatStatusLine() {
     const percent = Number.isFinite(this.contextPercentLeft) ? Math.max(0, Math.min(100, this.contextPercentLeft)) : 100;
     const queueCount = this.inkRenderer?.getQueueCount() ?? this.persistentInput.getQueueLength();
@@ -15421,7 +16758,7 @@ ${chalk14.gray("\u203A")} ${inputPreview}${chalk14.gray("\u258B")}`;
 import fs20 from "fs-extra";
 import os8 from "os";
 import path19 from "path";
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 var AVAILABLE_TOOLS = {
   file: [
     "read_file",
@@ -15498,7 +16835,7 @@ var PYTHON_FRAMEWORKS = {
   tensorflow: ["tensorflow"],
   pytorch: ["torch"]
 };
-var ProjectAnalyzer = class {
+var ProjectAnalyzer2 = class {
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
   }
@@ -15852,8 +17189,8 @@ async function runAutoSkillGeneration(workspaceRoot, llm) {
     skillsGenerated: 0,
     skills: []
   };
-  console.log(chalk15.cyan("Analyzing project structure..."));
-  const analyzer = new ProjectAnalyzer(workspaceRoot);
+  console.log(chalk16.cyan("Analyzing project structure..."));
+  const analyzer = new ProjectAnalyzer2(workspaceRoot);
   let analysis;
   try {
     analysis = await analyzer.analyze();
@@ -15862,17 +17199,17 @@ async function runAutoSkillGeneration(workspaceRoot, llm) {
     return result;
   }
   if (analysis.languages.length === 0 && analysis.frameworks.length === 0) {
-    console.log(chalk15.yellow("Could not detect project type. No skills generated."));
+    console.log(chalk16.yellow("Could not detect project type. No skills generated."));
     result.error = "Could not detect project type";
     return result;
   }
   const detected = [...analysis.languages, ...analysis.frameworks, ...analysis.patterns].join(", ");
-  console.log(chalk15.gray(`Detected: ${detected}`));
-  console.log(chalk15.gray(`Platform: ${analysis.platform}`));
-  console.log(chalk15.cyan("Generating skills..."));
+  console.log(chalk16.gray(`Detected: ${detected}`));
+  console.log(chalk16.gray(`Platform: ${analysis.platform}`));
+  console.log(chalk16.cyan("Generating skills..."));
   const skills = await generateAutoSkills(analysis, llm);
   if (skills.length === 0) {
-    console.log(chalk15.yellow("No skills generated."));
+    console.log(chalk16.yellow("No skills generated."));
     result.error = "No skills generated";
     return result;
   }
@@ -15882,17 +17219,17 @@ async function runAutoSkillGeneration(workspaceRoot, llm) {
     if (saved) {
       result.skillsGenerated++;
       result.skills.push(skill.name);
-      console.log(chalk15.green(`  \u2713 ${skill.name}`));
+      console.log(chalk16.green(`  \u2713 ${skill.name}`));
       if (skill.allowedTools && skill.allowedTools.length > 0) {
-        console.log(chalk15.gray(`    Tools: ${skill.allowedTools.slice(0, 5).join(", ")}${skill.allowedTools.length > 5 ? "..." : ""}`));
+        console.log(chalk16.gray(`    Tools: ${skill.allowedTools.slice(0, 5).join(", ")}${skill.allowedTools.length > 5 ? "..." : ""}`));
       }
     }
   }
   if (result.skillsGenerated > 0) {
     result.success = true;
-    console.log(chalk15.green(`
+    console.log(chalk16.green(`
 \u2713 Generated ${result.skillsGenerated} skills in ${skillsDir}`));
-    console.log(chalk15.gray(`  Use "/skills" to view and "/skills use <name>" to activate`));
+    console.log(chalk16.gray(`  Use "/skills" to view and "/skills use <name>" to activate`));
   }
   return result;
 }
@@ -16454,6 +17791,22 @@ ${sel.text}
         }
         process.stderr.write(`[RPC DEBUG] Instruction completed, success=${success}, content length=${this.currentMessageContent.length}
 `);
+        const turnDuration = this.turnStartTime ? Date.now() - this.turnStartTime : 0;
+        const hookManager = this.agent?.getHookManager?.();
+        if (hookManager) {
+          const snapshot2 = this.agent?.getStatusSnapshot();
+          await hookManager.executeHooks("stop", {
+            sessionId: this.sessionId || void 0,
+            turnDuration,
+            tokensUsed: snapshot2?.tokensUsed ?? 0
+          });
+          this.emitHookStop(
+            snapshot2?.tokensUsed ?? 0,
+            0,
+            // toolCallsCount - not tracked per turn currently
+            turnDuration
+          );
+        }
       } catch (err) {
         const errorMessage = err instanceof Error ? err.message : String(err);
         const errorStack = err instanceof Error ? err.stack : "";
@@ -17504,7 +18857,7 @@ async function handleSingleRequest(request, adapter) {
 process.title = "autohand";
 function getGitCommit() {
   if (true) {
-    return "5392e8c";
+    return "fc318c0";
   }
   try {
     return execSync3("git rev-parse --short HEAD", { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }).trim();
@@ -17562,7 +18915,7 @@ process.on("unhandledRejection", (reason, promise) => {
   globalThis.__autohandLastError = reason;
   console.error("[DEBUG] Unhandled Rejection at:", promise, "reason:", reason);
 });
-var ASCII_FRIEND = [
+var ASCII_FRIEND2 = [
   "\u2880\u2874\u281B\u281B\u283B\u28F7\u2844\u2800\u28E0\u2876\u281F\u281B\u283B\u28F6\u2844\u2880\u28F4\u287E\u281B\u281B\u28BF\u28E6\u2800\u2880\u28F4\u281E\u281B\u281B\u2836\u2840",
   "\u284E\u2800\u28B0\u28F6\u2846\u2808\u28FF\u28F4\u28FF\u2801\u28F4\u28F6\u2844\u2818\u28FF\u28FE\u284F\u2880\u28F6\u28E6\u2800\u28BB\u2847\u28FF\u2803\u28A0\u28F6\u2846\u2800\u28B9",
   "\u28A7\u2800\u2818\u281B\u2803\u28A0\u287F\u2819\u28FF\u2840\u2819\u281B\u2803\u28F0\u287F\u28BB\u28E7\u2808\u281B\u281B\u2880\u28FE\u2807\u28BB\u28C6\u2808\u281B\u280B\u2800\u287C",
@@ -17573,7 +18926,7 @@ var ASCII_FRIEND = [
   "\u2808\u28BF\u28E6\u28E4\u28F4\u287F\u2803\u2800\u2819\u28B7\u28E6\u28E4\u28F6\u287F\u2801\u2808\u283B\u28F7\u28E4\u28E4\u287E\u281B\u2800\u2808\u28BF\u28E6\u28E4\u28E4\u2834\u2801"
 ].join("\n");
 var program = new Command();
-program.name("autohand").description("Autonomous LLM-powered coding agent CLI").version(getVersionString(), "-v, --version", "output the current version").option("-p, --prompt <text>", "Run a single instruction in command mode").option("--path <path>", "Workspace path to operate in").option("-y, --yes", "Auto-confirm risky actions", false).option("--dry-run", "Preview actions without applying mutations", false).option("-d, --debug", "Enable debug output (verbose logging)", false).option("--model <model>", "Override the configured LLM model").option("--config <path>", "Path to config file (default ~/.autohand/config.json)").option("--temperature <value>", "Sampling temperature", parseFloat).option("-c, --auto-commit", "Auto-commit with LLM-generated message (runs lint & test first)", false).option("--unrestricted", "Run without any approval prompts (use with caution)", false).option("--restricted", "Deny all dangerous operations automatically", false).option("--auto-skill", "Auto-generate skills based on project analysis", false).option("--skill-install [skill-name]", "Install a community skill (opens browser if no name)").option("--project", "Install skill to project level (with --skill-install)", false).option("--permissions", "Display current permission settings and exit", false).option("--patch", "Generate git patch without applying changes (requires --prompt)", false).option("--output <file>", "Output file for patch (default: stdout, used with --patch)").option("--mode <mode>", "Run mode: interactive (default) or rpc", "interactive").option("--auto-mode <prompt>", "Start autonomous development loop with the given task").option("--max-iterations <n>", "Max auto-mode iterations (default: 50)", parseInt).option("--completion-promise <text>", 'Completion marker text (default: "DONE")').option("--no-worktree", "Disable git worktree isolation in auto-mode").option("--checkpoint-interval <n>", "Git commit every N iterations (default: 5)", parseInt).option("--max-runtime <m>", "Max runtime in minutes (default: 120)", parseInt).option("--max-cost <d>", "Max API cost in dollars (default: 10)", parseFloat).action(async (opts) => {
+program.name("autohand").description("Autonomous LLM-powered coding agent CLI").version(getVersionString(), "-v, --version", "output the current version").option("-p, --prompt <text>", "Run a single instruction in command mode").option("--path <path>", "Workspace path to operate in").option("-y, --yes", "Auto-confirm risky actions", false).option("--dry-run", "Preview actions without applying mutations", false).option("-d, --debug", "Enable debug output (verbose logging)", false).option("--model <model>", "Override the configured LLM model").option("--config <path>", "Path to config file (default ~/.autohand/config.json)").option("--temperature <value>", "Sampling temperature", parseFloat).option("-c, --auto-commit", "Auto-commit with LLM-generated message (runs lint & test first)", false).option("--unrestricted", "Run without any approval prompts (use with caution)", false).option("--restricted", "Deny all dangerous operations automatically", false).option("--auto-skill", "Auto-generate skills based on project analysis", false).option("--skill-install [skill-name]", "Install a community skill (opens browser if no name)").option("--project", "Install skill to project level (with --skill-install)", false).option("--permissions", "Display current permission settings and exit", false).option("--login", "Sign in to your Autohand account", false).option("--logout", "Sign out of your Autohand account", false).option("--patch", "Generate git patch without applying changes (requires --prompt)", false).option("--output <file>", "Output file for patch (default: stdout, used with --patch)").option("--mode <mode>", "Run mode: interactive (default) or rpc", "interactive").option("--auto-mode <prompt>", "Start autonomous development loop with the given task").option("--max-iterations <n>", "Max auto-mode iterations (default: 50)", parseInt).option("--completion-promise <text>", 'Completion marker text (default: "DONE")').option("--no-worktree", "Disable git worktree isolation in auto-mode").option("--checkpoint-interval <n>", "Git commit every N iterations (default: 5)", parseInt).option("--max-runtime <m>", "Max runtime in minutes (default: 120)", parseInt).option("--max-cost <d>", "Max API cost in dollars (default: 10)", parseFloat).option("--setup", "Run the setup wizard to configure or reconfigure Autohand", false).action(async (opts) => {
   if (opts.skillInstall !== void 0) {
     await runSkillInstall(opts);
     return;
@@ -17582,6 +18935,34 @@ program.name("autohand").description("Autonomous LLM-powered coding agent CLI").
     await displayPermissions(opts);
     return;
   }
+  if (opts.login) {
+    const { login } = await import("./login-NYWZRZO5.js");
+    const config = await loadConfig(opts.config);
+    await login({ config });
+    process.exit(0);
+  }
+  if (opts.logout) {
+    const { logout } = await import("./logout-MBS7L3ZW.js");
+    const config = await loadConfig(opts.config);
+    await logout({ config });
+    process.exit(0);
+  }
+  if (opts.setup) {
+    const config = await loadConfig(opts.config);
+    const workspaceRoot = resolveWorkspaceRoot(config, opts.path);
+    const wizard = new SetupWizard(workspaceRoot, config);
+    const result = await wizard.run({ skipWelcome: false });
+    if (result.cancelled) {
+      console.log(chalk17.gray("\nSetup cancelled."));
+      process.exit(0);
+    }
+    if (result.success) {
+      const newConfig = { ...config, ...result.config };
+      await saveConfig(newConfig);
+      console.log(chalk17.green("\nSetup complete! Run `autohand` to start."));
+    }
+    process.exit(0);
+  }
   if (opts.patch) {
     await runPatchMode(opts);
     return;
@@ -17600,59 +18981,38 @@ program.name("autohand").description("Autonomous LLM-powered coding agent CLI").
 program.command("resume <sessionId>").description("Resume a previous session").option("--path <path>", "Workspace path to operate in").option("--model <model>", "Override the configured LLM model").action(async (sessionId, opts) => {
   await runCLI({ ...opts, resumeSessionId: sessionId });
 });
+program.command("login").description("Sign in to your Autohand account").action(async () => {
+  const { login } = await import("./login-NYWZRZO5.js");
+  const config = await loadConfig();
+  await login({ config });
+  process.exit(0);
+});
+program.command("logout").description("Sign out of your Autohand account").action(async () => {
+  const { logout } = await import("./logout-MBS7L3ZW.js");
+  const config = await loadConfig();
+  await logout({ config });
+  process.exit(0);
+});
 async function runCLI(options) {
   const statusPanel = null;
   try {
     let config = await loadConfig(options.config);
+    const workspaceRoot = resolveWorkspaceRoot(config, options.path);
     const providerName = config.provider ?? "openrouter";
     const providerConfig = getProviderConfig(config, providerName);
     if (!providerConfig) {
-      if (config.isNewConfig) {
-        console.log(chalk16.cyan("\n\u2728 Welcome to Autohand!\n"));
-        console.log(chalk16.gray(`Config created at: ${config.configPath}
-`));
-      }
-      console.log(chalk16.yellow(`No ${providerName} API key configured.
-`));
-      let apiKey;
-      try {
-        const result = await enquirer4.prompt({
-          type: "password",
-          name: "apiKey",
-          message: `Enter your ${providerName === "openrouter" ? "OpenRouter" : providerName} API key`,
-          validate: (val) => {
-            if (typeof val !== "string" || !val.trim()) {
-              return "API key is required";
-            }
-            return true;
-          }
-        });
-        apiKey = result.apiKey;
-      } catch (error) {
-        if (error?.code === "ERR_USE_AFTER_CLOSE" || error?.message?.includes("cancelled")) {
-          console.log(chalk16.gray("\nSetup cancelled."));
-          process.exit(0);
-        }
-        throw error;
+      const wizard = new SetupWizard(workspaceRoot, config);
+      const result = await wizard.run({ skipWelcome: !config.isNewConfig });
+      if (result.cancelled) {
+        console.log(chalk17.gray("\nSetup cancelled."));
+        process.exit(0);
       }
-      if (providerName === "openrouter") {
-        config.openrouter = {
-          ...config.openrouter,
-          apiKey: apiKey.trim(),
-          baseUrl: config.openrouter?.baseUrl || "https://openrouter.ai/api/v1",
-          model: config.openrouter?.model || "anthropic/claude-sonnet-4-20250514"
-        };
-      } else if (providerName === "openai") {
-        config.openai = {
-          ...config.openai,
-          apiKey: apiKey.trim(),
-          model: config.openai?.model || "gpt-4o"
-        };
+      if (result.success) {
+        config = { ...config, ...result.config };
+        await saveConfig(config);
+        console.log();
       }
-      await saveConfig(config);
-      console.log(chalk16.green("\u2713 API key saved to config\n"));
     }
-    const workspaceRoot = resolveWorkspaceRoot(config, options.path);
     const safetyCheck = checkWorkspaceSafety(workspaceRoot);
     if (!safetyCheck.safe) {
       printDangerousWorkspaceWarning(workspaceRoot, safetyCheck);
@@ -17672,7 +19032,7 @@ async function runCLI(options) {
     const checkResults = await runStartupChecks(workspaceRoot);
     printStartupCheckResults(checkResults);
     if (!checkResults.allRequiredMet) {
-      console.log(chalk16.yellow("Continuing anyway, but some features may not work correctly.\n"));
+      console.log(chalk17.yellow("Continuing anyway, but some features may not work correctly.\n"));
     }
     if (options.model) {
       const providerName2 = config.provider ?? "openrouter";
@@ -17687,16 +19047,17 @@ async function runCLI(options) {
     const llmProvider = ProviderFactory.create(config);
     const files = new FileActionManager(workspaceRoot);
     if (options.autoSkill) {
-      console.log(chalk16.cyan("\nAuto-generating skills for this project...\n"));
+      console.log(chalk17.cyan("\nAuto-generating skills for this project...\n"));
       const result = await runAutoSkillGeneration(workspaceRoot, llmProvider);
       if (!result.success) {
-        console.log(chalk16.yellow(result.error || "Failed to generate skills"));
+        console.log(chalk17.yellow(result.error || "Failed to generate skills"));
       }
       return;
     }
     const agent = new AutohandAgent(llmProvider, files, runtime);
     if (options.prompt) {
       await agent.runCommandMode(options.prompt);
+      process.exit(0);
     } else if (options.resumeSessionId) {
       await agent.resumeSession(options.resumeSessionId);
     } else {
@@ -17704,7 +19065,7 @@ async function runCLI(options) {
     }
   } catch (error) {
     if (error instanceof Error) {
-      console.error(chalk16.red(error.message));
+      console.error(chalk17.red(error.message));
     } else {
       console.error(error);
     }
@@ -17716,7 +19077,7 @@ function printBanner() {
     return;
   }
   if (process.stdout.isTTY) {
-    console.log(chalk16.gray(ASCII_FRIEND));
+    console.log(chalk17.gray(ASCII_FRIEND2));
   } else {
     console.log("autohand");
   }
@@ -17734,28 +19095,28 @@ function printWelcome(runtime, authUser, versionCheck) {
     }
   })();
   const dir = runtime.workspaceRoot;
-  let versionLine = `${chalk16.bold("> Autohand")} v${getVersionString()}`;
+  let versionLine = `${chalk17.bold("> Autohand")} v${getVersionString()}`;
   if (versionCheck) {
     if (versionCheck.isUpToDate) {
-      versionLine += chalk16.green(" \u2713 Up to date");
+      versionLine += chalk17.green(" \u2713 Up to date");
     } else if (versionCheck.updateAvailable && versionCheck.latestVersion) {
-      versionLine += chalk16.yellow(` \u2B06 Update available: v${versionCheck.latestVersion}`);
+      versionLine += chalk17.yellow(` \u2B06 Update available: v${versionCheck.latestVersion}`);
     }
   }
   console.log(versionLine);
   if (versionCheck?.updateAvailable) {
-    console.log(chalk16.gray("  \u21B3 Run: ") + chalk16.cyan("curl -fsSL https://autohand.ai/install.sh | sh"));
+    console.log(chalk17.gray("  \u21B3 Run: ") + chalk17.cyan("curl -fsSL https://autohand.ai/install.sh | sh"));
   }
   if (authUser) {
-    console.log(chalk16.green(`Welcome back, ${authUser.name || authUser.email}!`));
+    console.log(chalk17.green(`Welcome back, ${authUser.name || authUser.email}!`));
   }
-  console.log(`${chalk16.gray("model:")} ${chalk16.cyan(model)}  ${chalk16.gray("| directory:")} ${chalk16.cyan(dir)}`);
+  console.log(`${chalk17.gray("model:")} ${chalk17.cyan(model)}  ${chalk17.gray("| directory:")} ${chalk17.cyan(dir)}`);
   console.log();
-  console.log(chalk16.gray("To get started, describe a task or try one of these commands:"));
-  console.log(chalk16.cyan("/init ") + chalk16.gray("create an AGENTS.md file with instructions for Autohand"));
-  console.log(chalk16.cyan("/help ") + chalk16.gray("review my current changes and find issues"));
+  console.log(chalk17.gray("To get started, describe a task or try one of these commands:"));
+  console.log(chalk17.cyan("/init ") + chalk17.gray("create an AGENTS.md file with instructions for Autohand"));
+  console.log(chalk17.cyan("/help ") + chalk17.gray("review my current changes and find issues"));
   if (!authUser) {
-    console.log(chalk16.cyan("/login ") + chalk16.gray("sign in to your Autohand account"));
+    console.log(chalk17.cyan("/login ") + chalk17.gray("sign in to your Autohand account"));
   }
   console.log();
 }
@@ -17810,44 +19171,44 @@ async function displayPermissions(opts) {
   const blacklist = manager.getBlacklist();
   const settings = manager.getSettings();
   console.log();
-  console.log(chalk16.bold.cyan("Autohand Permissions"));
-  console.log(chalk16.gray("\u2500".repeat(60)));
+  console.log(chalk17.bold.cyan("Autohand Permissions"));
+  console.log(chalk17.gray("\u2500".repeat(60)));
   console.log();
-  console.log(chalk16.bold("Mode:"), chalk16.cyan(settings.mode || "interactive"));
+  console.log(chalk17.bold("Mode:"), chalk17.cyan(settings.mode || "interactive"));
   console.log();
-  console.log(chalk16.bold("Workspace:"), chalk16.gray(workspaceRoot));
-  console.log(chalk16.bold("Config:"), chalk16.gray(config.configPath));
+  console.log(chalk17.bold("Workspace:"), chalk17.gray(workspaceRoot));
+  console.log(chalk17.bold("Config:"), chalk17.gray(config.configPath));
   console.log();
-  console.log(chalk16.bold.green("Approved (Whitelist)"));
+  console.log(chalk17.bold.green("Approved (Whitelist)"));
   if (whitelist.length === 0) {
-    console.log(chalk16.gray("  No approved patterns"));
+    console.log(chalk17.gray("  No approved patterns"));
   } else {
     whitelist.forEach((pattern, index) => {
-      console.log(chalk16.green(`  ${index + 1}. ${pattern}`));
+      console.log(chalk17.green(`  ${index + 1}. ${pattern}`));
     });
   }
   console.log();
-  console.log(chalk16.bold.red("Denied (Blacklist)"));
+  console.log(chalk17.bold.red("Denied (Blacklist)"));
   if (blacklist.length === 0) {
-    console.log(chalk16.gray("  No denied patterns"));
+    console.log(chalk17.gray("  No denied patterns"));
   } else {
     blacklist.forEach((pattern, index) => {
-      console.log(chalk16.red(`  ${index + 1}. ${pattern}`));
+      console.log(chalk17.red(`  ${index + 1}. ${pattern}`));
     });
   }
   console.log();
-  console.log(chalk16.gray("\u2500".repeat(60)));
-  console.log(chalk16.bold("Summary:"), `${whitelist.length} approved, ${blacklist.length} denied`);
+  console.log(chalk17.gray("\u2500".repeat(60)));
+  console.log(chalk17.bold("Summary:"), `${whitelist.length} approved, ${blacklist.length} denied`);
   console.log();
-  console.log(chalk16.gray("Use /permissions in interactive mode to manage permissions."));
-  console.log(chalk16.gray("Use --unrestricted to skip all approval prompts."));
-  console.log(chalk16.gray("Use --restricted to deny all dangerous operations."));
+  console.log(chalk17.gray("Use /permissions in interactive mode to manage permissions."));
+  console.log(chalk17.gray("Use --unrestricted to skip all approval prompts."));
+  console.log(chalk17.gray("Use --restricted to deny all dangerous operations."));
   console.log();
 }
 async function runPatchMode(opts) {
   if (!opts.prompt) {
-    console.error(chalk16.red("Error: --patch requires --prompt to specify the instruction"));
-    console.error(chalk16.gray('Usage: autohand --prompt "your instruction" --patch'));
+    console.error(chalk17.red("Error: --patch requires --prompt to specify the instruction"));
+    console.error(chalk17.gray('Usage: autohand --prompt "your instruction" --patch'));
     process.exit(1);
   }
   const fs21 = await import("fs-extra");
@@ -17881,23 +19242,23 @@ async function runPatchMode(opts) {
     workspaceRoot,
     options: patchOptions
   };
-  console.error(chalk16.cyan("Patch Mode: Changes will be captured without modifying files\n"));
+  console.error(chalk17.cyan("Patch Mode: Changes will be captured without modifying files\n"));
   try {
     const agent = new AutohandAgent(llmProvider, files, runtime);
     await agent.runCommandMode(opts.prompt);
     const changes = files.getPendingChanges();
     if (changes.length === 0) {
-      console.error(chalk16.yellow("\nNo changes were made."));
+      console.error(chalk17.yellow("\nNo changes were made."));
       process.exit(0);
     }
     const patch = generateUnifiedPatch(changes);
-    console.error(chalk16.green(`
+    console.error(chalk17.green(`
 \u2713 ${formatChangeSummary(changes)}`));
     if (opts.output) {
       await fs21.default.ensureDir((await import("path")).dirname(opts.output));
       await fs21.default.writeFile(opts.output, patch);
-      console.error(chalk16.green(`\u2713 Patch written to ${opts.output}`));
-      console.error(chalk16.gray("\nTo apply: git apply " + opts.output));
+      console.error(chalk17.green(`\u2713 Patch written to ${opts.output}`));
+      console.error(chalk17.gray("\nTo apply: git apply " + opts.output));
     } else {
       process.stdout.write(patch);
     }
@@ -17905,14 +19266,14 @@ async function runPatchMode(opts) {
     process.exit(0);
   } catch (error) {
     files.exitPreviewMode();
-    console.error(chalk16.red(`
+    console.error(chalk17.red(`
 Error: ${error.message}`));
     process.exit(1);
   }
 }
 async function runAutoMode(opts) {
   if (!opts.autoMode) {
-    console.error(chalk16.red("Error: --auto-mode requires a task prompt"));
+    console.error(chalk17.red("Error: --auto-mode requires a task prompt"));
     process.exit(1);
   }
   const config = await loadConfig(opts.config);
@@ -17934,9 +19295,9 @@ async function runAutoMode(opts) {
   }
   const { AutomodeManager, getAutomodeOptions } = await import("./AutomodeManager-WIMHLG4W.js");
   const { HookManager: HookManager2 } = await import("./HookManager-VIX56KFU.js");
-  const { SessionManager: SessionManager2 } = await import("./SessionManager-IMW2HGR3.js");
+  const { SessionManager: SessionManager2 } = await import("./SessionManager-XDBEQUPG.js");
   const { MemoryManager: MemoryManager2 } = await import("./MemoryManager-UVHILGV5.js");
-  const readline5 = await import("readline");
+  const readline3 = await import("readline");
   const llmProvider = ProviderFactory.create(config);
   const files = new FileActionManager(workspaceRoot);
   const providerName = config.provider ?? "openrouter";
@@ -17954,26 +19315,26 @@ async function runAutoMode(opts) {
   const automodeManager = new AutomodeManager(config, workspaceRoot, hookManager, session, memoryManager);
   const automodeOptions = getAutomodeOptions(opts, config);
   if (!automodeOptions) {
-    console.error(chalk16.red("Error: Failed to parse auto-mode options"));
+    console.error(chalk17.red("Error: Failed to parse auto-mode options"));
     process.exit(1);
   }
   printBanner();
-  console.log(chalk16.bold.cyan("\n\u{1F504} Auto-Mode: Autonomous Development Loop\n"));
-  console.log(chalk16.gray("Task:"), chalk16.white(opts.autoMode));
-  console.log(chalk16.gray("Max Iterations:"), chalk16.cyan(automodeOptions.maxIterations ?? 50));
-  console.log(chalk16.gray("Completion Marker:"), chalk16.cyan(automodeOptions.completionPromise ?? "DONE"));
-  console.log(chalk16.gray("Worktree Isolation:"), chalk16.cyan(automodeOptions.useWorktree !== false ? "enabled" : "disabled"));
+  console.log(chalk17.bold.cyan("\n\u{1F504} Auto-Mode: Autonomous Development Loop\n"));
+  console.log(chalk17.gray("Task:"), chalk17.white(opts.autoMode));
+  console.log(chalk17.gray("Max Iterations:"), chalk17.cyan(automodeOptions.maxIterations ?? 50));
+  console.log(chalk17.gray("Completion Marker:"), chalk17.cyan(automodeOptions.completionPromise ?? "DONE"));
+  console.log(chalk17.gray("Worktree Isolation:"), chalk17.cyan(automodeOptions.useWorktree !== false ? "enabled" : "disabled"));
   console.log();
   if (process.stdin.isTTY) {
-    readline5.emitKeypressEvents(process.stdin);
+    readline3.emitKeypressEvents(process.stdin);
     process.stdin.setRawMode(true);
     process.stdin.on("keypress", (_str, key) => {
       if (key && key.name === "escape") {
-        console.log(chalk16.yellow("\n\u26A0\uFE0F  Cancelling auto-mode..."));
+        console.log(chalk17.yellow("\n\u26A0\uFE0F  Cancelling auto-mode..."));
         automodeManager.cancel("user_escape");
       }
       if (key && key.ctrl && key.name === "c") {
-        console.log(chalk16.yellow("\n\u26A0\uFE0F  Cancelling auto-mode..."));
+        console.log(chalk17.yellow("\n\u26A0\uFE0F  Cancelling auto-mode..."));
         automodeManager.cancel("user_escape");
         if (process.stdin.isTTY) {
           process.stdin.setRawMode(false);
@@ -18005,7 +19366,7 @@ async function runAutoMode(opts) {
       } catch (err) {
         success = false;
         error = err.message;
-        console.error(chalk16.red(`Iteration error: ${error}`));
+        console.error(chalk17.red(`Iteration error: ${error}`));
       }
       return {
         success,
@@ -18022,17 +19383,50 @@ async function runAutoMode(opts) {
     if (finalState) {
       session.metadata.automodeIterations = finalState.currentIteration;
       const statusText = finalState.status === "completed" ? "completed" : `ended (${finalState.status})`;
-      await sessionManager.closeSession(`Auto-mode ${statusText} after ${finalState.currentIteration} iterations: ${opts.autoMode?.slice(0, 50)}...`);
-      console.log(chalk16.gray(`
+      console.log(chalk17.gray(`
+\u{1F4CA} Auto-mode ${statusText} after ${finalState.currentIteration} iterations`));
+    }
+    console.log(chalk17.cyan("\n\u{1F504} Auto-mode finished. You can continue working interactively.\n"));
+    console.log(chalk17.gray("Press Enter to continue in interactive mode, or Ctrl+C to exit.\n"));
+    const continuePromise = new Promise((resolve) => {
+      if (!process.stdin.isTTY) {
+        resolve(false);
+        return;
+      }
+      readline3.emitKeypressEvents(process.stdin);
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      const handleKey = (_str, key) => {
+        process.stdin.off("keypress", handleKey);
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(false);
+        }
+        if (key && key.ctrl && key.name === "c") {
+          resolve(false);
+        } else if (key && key.name === "return") {
+          resolve(true);
+        } else {
+          resolve(true);
+        }
+      };
+      process.stdin.on("keypress", handleKey);
+    });
+    const shouldContinue = await continuePromise;
+    if (!shouldContinue) {
+      const statusText = finalState?.status === "completed" ? "completed" : `ended (${finalState?.status})`;
+      await sessionManager.closeSession(`Auto-mode ${statusText} after ${finalState?.currentIteration ?? 0} iterations: ${opts.autoMode?.slice(0, 50)}...`);
+      console.log(chalk17.gray(`
 \u{1F4C1} Session saved: ${session.metadata.sessionId}`));
+      process.exit(finalState?.status === "completed" ? 0 : 1);
     }
-    process.exit(finalState?.status === "completed" ? 0 : 1);
+    console.log(chalk17.cyan("\n\u25B6\uFE0F Continuing in interactive mode...\n"));
+    await agent.runInteractive();
   } catch (error) {
     if (process.stdin.isTTY) {
       process.stdin.setRawMode(false);
     }
     await sessionManager.closeSession(`Auto-mode failed: ${error.message}`);
-    console.error(chalk16.red(`
+    console.error(chalk17.red(`
 Auto-mode error: ${error.message}`));
     process.exit(1);
   }