autohand-cli 0.7.4 → 0.7.6

package/dist/index.cjs

@@ -2,9 +2,10 @@
 "use strict"; function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
 
 var _chunkOKMYLMCRcjs = require('./chunk-OKMYLMCR.cjs');
+require('./chunk-3CO5R6M2.cjs');
 
 
-var _chunkUPR5PKX4cjs = require('./chunk-UPR5PKX4.cjs');
+var _chunk67NJKV5Acjs = require('./chunk-67NJKV5A.cjs');
 
 
 var _chunkURY4AS4Lcjs = require('./chunk-URY4AS4L.cjs');
@@ -28,7 +29,9 @@ var _chunkHYTYXN2Gcjs = require('./chunk-HYTYXN2G.cjs');
 
 
 var _chunkOTS4YFSZcjs = require('./chunk-OTS4YFSZ.cjs');
-require('./chunk-3CO5R6M2.cjs');
+
+
+var _chunkK6NBYSMEcjs = require('./chunk-K6NBYSME.cjs');
 
 
 var _chunkM7RVTUWEcjs = require('./chunk-M7RVTUWE.cjs');
@@ -40,8 +43,10 @@ var _chunkJBKP2CLAcjs = require('./chunk-JBKP2CLA.cjs');
 var _chunkC3IFF3EHcjs = require('./chunk-C3IFF3EH.cjs');
 
 
+var _chunkKJ67C72Ccjs = require('./chunk-KJ67C72C.cjs');
 
-var _chunkXJZYEURAcjs = require('./chunk-XJZYEURA.cjs');
+
+var _chunkJYTXG6OVcjs = require('./chunk-JYTXG6OV.cjs');
 
 
 var _chunk2E2COWKBcjs = require('./chunk-2E2COWKB.cjs');
@@ -95,26 +100,26 @@ var _chunkKNLBEUAVcjs = require('./chunk-KNLBEUAV.cjs');
 var _chunkZ4J4W6YQcjs = require('./chunk-Z4J4W6YQ.cjs');
 
 
+var _chunkXT4OSHSBcjs = require('./chunk-XT4OSHSB.cjs');
 
 
+var _chunkV5MTBGM4cjs = require('./chunk-V5MTBGM4.cjs');
 
-var _chunkXTHHDIBGcjs = require('./chunk-XTHHDIBG.cjs');
 
+var _chunkWBDPILKIcjs = require('./chunk-WBDPILKI.cjs');
 
-var _chunkXT4OSHSBcjs = require('./chunk-XT4OSHSB.cjs');
 
 
-var _chunkV5MTBGM4cjs = require('./chunk-V5MTBGM4.cjs');
+var _chunkBEIG7V7Qcjs = require('./chunk-BEIG7V7Q.cjs');
 
 
-var _chunkWBDPILKIcjs = require('./chunk-WBDPILKI.cjs');
+var _chunk2W3QTBNGcjs = require('./chunk-2W3QTBNG.cjs');
 
 
 
-var _chunkBEIG7V7Qcjs = require('./chunk-BEIG7V7Q.cjs');
 
 
-var _chunkRYY5I7QNcjs = require('./chunk-RYY5I7QN.cjs');
+var _chunkXTHHDIBGcjs = require('./chunk-XTHHDIBG.cjs');
 
 
 var _chunkVMMGT42Ecjs = require('./chunk-VMMGT42E.cjs');
@@ -123,7 +128,6 @@ var _chunkVMMGT42Ecjs = require('./chunk-VMMGT42E.cjs');
 require('dotenv/config');
 var _commander = require('commander');
 var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
-var _enquirer = require('enquirer'); var _enquirer2 = _interopRequireDefault(_enquirer);
 var _child_process = require('child_process');
 
 // src/startup/checks.ts
@@ -228,20 +232,66 @@ async function checkWorkspaceWritable(workspaceRoot) {
     };
   }
 }
-function checkGitRepo(workspaceRoot) {
+function isEmptyDirectory(dir) {
+  try {
+    const entries = _fsextra2.default.readdirSync(dir);
+    const significantEntries = entries.filter((e) => !e.startsWith(".") || e === ".git");
+    return significantEntries.length === 0;
+  } catch (e3) {
+    return false;
+  }
+}
+function getGitBranch(workspaceRoot) {
   try {
     const result = _child_process.spawnSync.call(void 0, "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 (e4) {
+  }
+  try {
+    const result = _child_process.spawnSync.call(void 0, "git", ["symbolic-ref", "--short", "HEAD"], {
+      cwd: workspaceRoot,
+      encoding: "utf8",
+      timeout: 5e3
+    });
+    if (result.status === 0 && result.stdout.trim()) {
+      return result.stdout.trim();
+    }
+  } catch (e5) {
+  }
+  return void 0;
+}
+function checkGitRepo(workspaceRoot) {
+  const gitDirExists = _fsextra2.default.existsSync(`${workspaceRoot}/.git`);
+  if (gitDirExists) {
+    const branch = getGitBranch(workspaceRoot);
+    return {
+      isGitRepo: true,
+      branch
+    };
+  }
+  if (isEmptyDirectory(workspaceRoot)) {
+    try {
+      const initResult = _child_process.spawnSync.call(void 0, "git", ["init"], {
+        cwd: workspaceRoot,
+        encoding: "utf8",
+        timeout: 5e3
+      });
+      if (initResult.status === 0) {
+        const branch = getGitBranch(workspaceRoot) || "main";
+        return {
+          isGitRepo: true,
+          branch,
+          initialized: true
+        };
+      }
+    } catch (e6) {
     }
-  } catch (e3) {
   }
   return { isGitRepo: false };
 }
@@ -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(_chalk2.default.green("\u2713 Initialized git repository"));
+    console.log();
+  }
   if (missingRequired.length === 0 && !verbose) {
     return;
   }
@@ -389,7 +444,7 @@ function normalizePath(inputPath) {
   let normalized = path17.default.resolve(inputPath);
   try {
     normalized = _fsextra2.default.realpathSync(normalized);
-  } catch (e4) {
+  } catch (e7) {
   }
   if (normalized.length > 1 && normalized.endsWith(path17.default.sep)) {
     normalized = normalized.slice(0, -1);
@@ -611,7 +666,7 @@ async function readCache() {
       const data = await _fsextra2.default.readJson(CACHE_FILE);
       return data;
     }
-  } catch (e5) {
+  } catch (e8) {
   }
   return null;
 }
@@ -619,7 +674,7 @@ async function writeCache(cache) {
   try {
     await _fsextra2.default.ensureDir(path17.default.dirname(CACHE_FILE));
     await _fsextra2.default.writeJson(CACHE_FILE, cache, { spaces: 2 });
-  } catch (e6) {
+  } catch (e9) {
   }
 }
 function isCacheValid(cache, intervalHours) {
@@ -628,7 +683,7 @@ function isCacheValid(cache, intervalHours) {
     const now = /* @__PURE__ */ new Date();
     const hoursSinceCheck = (now.getTime() - lastCheck.getTime()) / (1e3 * 60 * 60);
     return hoursSinceCheck < intervalHours;
-  } catch (e7) {
+  } catch (e10) {
     return false;
   }
 }
@@ -654,7 +709,7 @@ async function fetchLatestRelease() {
         url: data.html_url || `https://github.com/autohandai/code-cli/releases/tag/${data.tag_name}`
       };
     }
-  } catch (e8) {
+  } catch (e11) {
   }
   return null;
 }
@@ -780,7 +835,7 @@ var GitIgnoreParser = class {
     let content = "";
     try {
       content = _fsextra2.default.readFileSync(patternsFilePath, "utf8");
-    } catch (e9) {
+    } catch (e12) {
       return [];
     }
     const isExcludeFile = patternsFilePath.endsWith(path17.default.join(".git", "info", "exclude"));
@@ -1188,7 +1243,7 @@ var FileActionManager = class {
           file: normalizedRel || path17.default.basename(current),
           snippet
         });
-      } catch (e10) {
+      } catch (e13) {
         continue;
       }
     }
@@ -1213,19 +1268,19 @@ var FileActionManager = class {
     let realPath;
     try {
       realPath = _fsextra2.default.realpathSync(resolved);
-    } catch (e11) {
+    } catch (e14) {
       const parentDir = path17.default.dirname(resolved);
       try {
         const realParent = _fsextra2.default.realpathSync(parentDir);
         realPath = path17.default.join(realParent, path17.default.basename(resolved));
-      } catch (e12) {
+      } catch (e15) {
         realPath = resolved;
       }
     }
     let realWorkspaceRoot;
     try {
       realWorkspaceRoot = _fsextra2.default.realpathSync(this.workspaceRoot);
-    } catch (e13) {
+    } catch (e16) {
       realWorkspaceRoot = this.workspaceRoot;
     }
     const rootWithSep = realWorkspaceRoot.endsWith(path17.default.sep) ? realWorkspaceRoot : `${realWorkspaceRoot}${path17.default.sep}`;
@@ -1270,7 +1325,7 @@ var FileActionManager = class {
             }
           }
         }
-      } catch (e14) {
+      } catch (e17) {
         continue;
       }
     }
@@ -1373,7 +1428,7 @@ var OllamaProvider = class {
     try {
       const response = await fetch(`${this.baseUrl}/api/tags`);
       return response.ok;
-    } catch (e15) {
+    } catch (e18) {
       return false;
     }
   }
@@ -1431,7 +1486,7 @@ var OllamaProvider = class {
           delete body.tools;
           return this.complete(request);
         }
-      } catch (e16) {
+      } catch (e19) {
       }
       throw new Error(`Ollama API error: ${response.status} ${response.statusText}${errorDetail}`);
     }
@@ -1488,7 +1543,7 @@ var OllamaProvider = class {
             const data = JSON.parse(line);
             fullContent += data.message.content;
             lastData = data;
-          } catch (e17) {
+          } catch (e20) {
           }
         }
       }
@@ -1534,7 +1589,7 @@ var OpenAIProvider = class {
         }
       });
       return response.ok;
-    } catch (e18) {
+    } catch (e21) {
       return false;
     }
   }
@@ -1638,7 +1693,7 @@ var LlamaCppProvider = class {
       }
       const data = await response.json();
       return _nullishCoalesce(_optionalChain([data, 'access', _7 => _7.data, 'optionalAccess', _8 => _8.map, 'call', _9 => _9((m) => m.id)]), () => ( [this.model]));
-    } catch (e19) {
+    } catch (e22) {
       return this.model ? [this.model] : [];
     }
   }
@@ -1646,7 +1701,7 @@ var LlamaCppProvider = class {
     try {
       const response = await fetch(`${this.baseUrl}/health`);
       return response.ok;
-    } catch (e20) {
+    } catch (e23) {
       return false;
     }
   }
@@ -1778,6 +1833,26 @@ var OpenRouterClient = class {
         payload.tool_choice = request.toolChoice;
       }
     }
+    const model = (_nullishCoalesce(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",
@@ -1904,10 +1979,10 @@ var OpenRouterClient = class {
       if (typeof errorDetail === "object") {
         errorDetail = JSON.stringify(errorDetail);
       }
-    } catch (e21) {
+    } catch (e24) {
       try {
         errorDetail = await response.text();
-      } catch (e22) {
+      } catch (e25) {
       }
     }
     const friendlyMessage = FRIENDLY_ERRORS[status];
@@ -2020,7 +2095,7 @@ var MLXProvider = class {
       }
       const data = await response.json();
       return _nullishCoalesce(_optionalChain([data, 'access', _42 => _42.data, 'optionalAccess', _43 => _43.map, 'call', _44 => _44((m) => m.id)]), () => ( (this.model ? [this.model] : [])));
-    } catch (e23) {
+    } catch (e26) {
       return this.model ? [this.model] : [];
     }
   }
@@ -2031,7 +2106,7 @@ var MLXProvider = class {
     try {
       const response = await fetch(`${this.baseUrl}/v1/models`);
       return response.ok;
-    } catch (e24) {
+    } catch (e27) {
       return false;
     }
   }
@@ -2203,12 +2278,11 @@ var ProviderFactory = class {
 var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
 
 var _ora = require('ora'); var _ora2 = _interopRequireDefault(_ora);
-
-var _readline = require('readline'); var _readline2 = _interopRequireDefault(_readline);
+var _enquirer = require('enquirer'); var _enquirer2 = _interopRequireDefault(_enquirer);
 
 // src/ui/inputPrompt.ts
 
-
+var _readline = require('readline'); var _readline2 = _interopRequireDefault(_readline);
 var _fs = require('fs');
 
 
@@ -2296,7 +2370,7 @@ var MentionPreview = class {
     this.disposed = false;
     this.lastSuggestions = [];
     const input = rl.input;
-    _readline2.default.emitKeypressEvents(input, rl);
+    safeEmitKeypressEvents(input);
     this.statusLine = statusLine ? _chalk2.default.gray(statusLine) : void 0;
     this.keypressHandler = this.handleKeypress.bind(this);
     input.prependListener("keypress", this.keypressHandler);
@@ -2630,7 +2704,7 @@ function parseBase64DataUrl(dataUrl) {
   try {
     const data = Buffer.from(base64Data, "base64");
     return { mimeType, data };
-  } catch (e25) {
+  } catch (e28) {
     return void 0;
   }
 }
@@ -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.default.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 (e29) {
   }
   const rl = _readline2.default.createInterface({
     input: stdInput,
@@ -2759,7 +2844,7 @@ async function promptOnce(options) {
 \u{1F4F7} Loaded image: ${filePath} -> [Image #${id}]
 `));
           }
-        } catch (e26) {
+        } catch (e30) {
         }
       }
     }
@@ -2799,7 +2884,7 @@ async function promptOnce(options) {
 \u{1F4F7} Loaded image: ${filePath} -> [Image #${id}]
 `));
           }
-        } catch (e27) {
+        } catch (e31) {
         }
       }
     }
@@ -2819,7 +2904,7 @@ async function promptOnce(options) {
 \u{1F4F7} Loaded image: ${filePath} -> [Image #${id}]
 `));
           }
-        } catch (e28) {
+        } catch (e32) {
         }
       }
     }
@@ -2893,6 +2978,9 @@ ${_chalk2.default.gray("Press Ctrl+C again to exit.")}
     input.on("keypress", handleKeypress);
     rl.setPrompt(`${_chalk2.default.gray("\u203A")} `);
     rl.prompt(true);
+    process.nextTick(() => {
+      stdOutput.write(`\r${_chalk2.default.gray("\u203A")} `);
+    });
     rl.on("line", (value) => {
       let finalValue = convertNewlineMarkersToNewlines(value).trim();
       finalValue = processImagesInText(finalValue);
@@ -3942,7 +4030,7 @@ var SLASH_COMMANDS = [
   _chunkV5MTBGM4cjs.metadata,
   _chunkBEIG7V7Qcjs.metadata,
   _chunkBEIG7V7Qcjs.aliasMetadata,
-  _chunkRYY5I7QNcjs.metadata,
+  _chunk2W3QTBNGcjs.metadata,
   _chunkVMMGT42Ecjs.metadata,
   _chunkMFK6HE47cjs.metadata,
   _chunk3ZUWWML7cjs.metadata,
@@ -3955,7 +4043,7 @@ var SLASH_COMMANDS = [
   _chunkM7RVTUWEcjs.metadata,
   _chunkJBKP2CLAcjs.metadata,
   _chunkC3IFF3EHcjs.metadata,
-  _chunkXJZYEURAcjs.metadata,
+  _chunkKJ67C72Ccjs.metadata,
   _chunk2E2COWKBcjs.metadata,
   _chunk536VWSZKcjs.metadata,
   _chunkB5N5UAMOcjs.metadata,
@@ -3964,7 +4052,8 @@ var SLASH_COMMANDS = [
   _chunkCT2VTDPQcjs.installMetadata,
   _chunkLUKMRIKJcjs.metadata,
   _chunkHYTYXN2Gcjs.metadata,
-  _chunkOTS4YFSZcjs.metadata
+  _chunkOTS4YFSZcjs.metadata,
+  _chunkK6NBYSMEcjs.metadata
 ];
 
 // src/core/conversationManager.ts
@@ -5743,7 +5832,7 @@ async function listDirectoryTree(root, options = {}) {
         if (stats.isDirectory() && currentDepth < depth) {
           await walk(full, `${prefix}  `, currentDepth + 1);
         }
-      } catch (e29) {
+      } catch (e33) {
         continue;
       }
       if (result.length >= maxEntries) {
@@ -5969,7 +6058,7 @@ var WorktreeManager = class {
       try {
         await this.remove(wt.path, { force: true, deleteBranch: options.removeMerged });
         removed.push(wt.path);
-      } catch (e30) {
+      } catch (e34) {
       }
     }
     _child_process.spawnSync.call(void 0, "git", ["worktree", "prune"], { cwd: this.repoRoot });
@@ -6046,7 +6135,7 @@ var WorktreeManager = class {
       } catch (error) {
         try {
           await this.runInWorktree(wt.path, `git ${strategy} --abort`);
-        } catch (e31) {
+        } catch (e35) {
         }
         failed.push(`${wt.path}: ${error.message}`);
       }
@@ -6399,7 +6488,7 @@ async function fetchUrl(url, options = {}) {
       try {
         const json = JSON.parse(content);
         return JSON.stringify(json, null, 2).slice(0, maxLength);
-      } catch (e32) {
+      } catch (e36) {
       }
     }
     const text = htmlToText(content);
@@ -6690,10 +6779,10 @@ var ToolsRegistry = class {
           if (this.isValidMetaTool(data)) {
             this.metaToolCache.set(data.name, data);
           }
-        } catch (e33) {
+        } catch (e37) {
         }
       }
-    } catch (e34) {
+    } catch (e38) {
     }
   }
   isValidMetaTool(candidate) {
@@ -7808,7 +7897,7 @@ ${result.removed.map((p) => `  - ${p}`).join("\n")}`;
           const content = await this.files.readFile(todoPath);
           const parsed = JSON.parse(content);
           existingTodos = Array.isArray(parsed) ? parsed : [];
-        } catch (e35) {
+        } catch (e39) {
         }
         const todoMap = new Map(existingTodos.map((t) => [t.id, t]));
         for (const task of action.tasks) {
@@ -8534,7 +8623,7 @@ var SlashCommandHandler = class {
           return feedback(this.ctx);
         }
         case "/resume": {
-          const { resume } = await Promise.resolve().then(() => _interopRequireWildcard(require("./resume-OYZMJRNO.cjs")));
+          const { resume } = await Promise.resolve().then(() => _interopRequireWildcard(require("./resume-ANISKRWL.cjs")));
           return resume({ sessionManager: this.ctx.sessionManager, args });
         }
         case "/sessions": {
@@ -8592,8 +8681,21 @@ var SlashCommandHandler = class {
           });
           return null;
         }
+        case "/share": {
+          const { execute } = await Promise.resolve().then(() => _interopRequireWildcard(require("./share-4ACH6626.cjs")));
+          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 Promise.resolve().then(() => _interopRequireWildcard(require("./status-U5NH6SYY.cjs")));
+          const { status } = await Promise.resolve().then(() => _interopRequireWildcard(require("./status-4U5CPUVT.cjs")));
           return status(this.ctx);
         }
         case "/login": {
@@ -8885,189 +8987,1169 @@ var ProjectManager = class {
   }
 };
 
-// src/core/agents/AgentDelegator.ts
-
+// src/onboarding/projectAnalyzer.ts
 
-// src/core/agents/SubAgent.ts
 
-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);
+var ProjectAnalyzer = class {
+  constructor(workspaceRoot) {
+    this.workspaceRoot = workspaceRoot;
   }
   /**
-   * Build system prompt with tool signatures for the LLM
+   * Analyze the workspace and return project information
    */
-  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");
+  async analyze() {
+    const info = {};
+    await this.analyzeNodeProject(info);
+    await this.analyzeRustProject(info);
+    await this.analyzeGoProject(info);
+    await this.analyzePythonProject(info);
+    return info;
   }
   /**
-   * Format a tool definition as a signature string
+   * Analyze Node.js/JavaScript/TypeScript project
    */
-  formatToolSignature(def) {
-    const params = _optionalChain([def, 'access', _185 => _185.parameters, 'optionalAccess', _186 => _186.properties]) ? Object.entries(def.parameters.properties).map(([name, prop]) => {
-      const required = _optionalChain([def, 'access', _187 => _187.parameters, 'optionalAccess', _188 => _188.required, 'optionalAccess', _189 => _189.includes, 'call', _190 => _190(name)]) ? "" : "?";
-      return `${name}${required}: ${prop.type}`;
-    }).join(", ") : "";
-    return `- ${def.name}(${params}): ${def.description}`;
-  }
-  async run(task) {
-    console.log(_chalk2.default.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 (_optionalChain([completion, 'access', _191 => _191.toolCalls, 'optionalAccess', _192 => _192.length])) {
-        this.conversation.addMessage({
-          role: "assistant",
-          content: completion.content || ""
-        });
+  async analyzeNodeProject(info) {
+    const pkgPath = _path.join.call(void 0, this.workspaceRoot, "package.json");
+    if (!await _fsextra.pathExists.call(void 0, pkgPath)) {
+      return;
+    }
+    try {
+      const pkg = await _fsextra.readJson.call(void 0, pkgPath);
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps.typescript || _optionalChain([pkg, 'access', _185 => _185.devDependencies, 'optionalAccess', _186 => _186.typescript])) {
+        info.language = "TypeScript";
       } else {
-        this.conversation.addMessage({ role: "assistant", content: completion.content });
-      }
-      if (payload.thought) {
-        console.log(_chalk2.default.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 = _optionalChain([completion, 'access', _193 => _193.toolCalls, 'optionalAccess', _194 => _194[j]]);
-          const content = result.success ? _nullishCoalesce(result.output, () => ( "(no output)")) : _nullishCoalesce(result.error, () => ( "Tool failed"));
-          this.conversation.addMessage({
-            role: "tool",
-            name: result.tool,
-            content,
-            tool_call_id: _optionalChain([toolCall, 'optionalAccess', _195 => _195.id])
-          });
-          if (!result.success) {
-            console.log(_chalk2.default.red(`[${this.name}] Tool ${result.tool} failed: ${content}`));
-          }
-        }
-        continue;
-      }
-      const response = _nullishCoalesce(_nullishCoalesce(payload.finalResponse, () => ( payload.response)), () => ( completion.content));
-      console.log(_chalk2.default.cyan(`[${this.name}] Finished.`));
-      return response;
+        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 (e40) {
     }
-    return `[${this.name}] Failed to complete task within ${maxIterations} iterations.`;
   }
   /**
-   * Parse LLM response, preferring native tool calls over JSON parsing
+   * Detect Node.js framework from dependencies
    */
-  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);
+  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;
   }
   /**
-   * Safely parse JSON, returning empty object on failure
+   * Detect Node.js package manager from lockfiles
+   */
+  async detectNodePackageManager() {
+    if (await _fsextra.pathExists.call(void 0, _path.join.call(void 0, this.workspaceRoot, "bun.lockb")) || await _fsextra.pathExists.call(void 0, _path.join.call(void 0, this.workspaceRoot, "bun.lock"))) {
+      return "bun";
+    }
+    if (await _fsextra.pathExists.call(void 0, _path.join.call(void 0, this.workspaceRoot, "pnpm-lock.yaml"))) {
+      return "pnpm";
+    }
+    if (await _fsextra.pathExists.call(void 0, _path.join.call(void 0, this.workspaceRoot, "yarn.lock"))) {
+      return "yarn";
+    }
+    if (await _fsextra.pathExists.call(void 0, _path.join.call(void 0, this.workspaceRoot, "package-lock.json"))) {
+      return "npm";
+    }
+    return "npm";
+  }
+  /**
+   * Detect Node.js test framework
+   */
+  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;
+  }
+  /**
+   * Detect Node.js linter
+   */
+  detectNodeLinter(deps) {
+    if (deps["@biomejs/biome"]) return "Biome";
+    if (deps.eslint) return "ESLint";
+    if (deps.oxlint) return "Oxlint";
+    return void 0;
+  }
+  /**
+   * Detect Node.js formatter
+   */
+  detectNodeFormatter(deps) {
+    if (deps.prettier) return "Prettier";
+    if (deps["@biomejs/biome"]) return "Biome";
+    if (deps.dprint) return "dprint";
+    return void 0;
+  }
+  /**
+   * 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 = _path.join.call(void 0, this.workspaceRoot, "Cargo.toml");
+    if (!await _fsextra.pathExists.call(void 0, cargoPath)) {
+      return;
+    }
+    info.language = "Rust";
+    info.packageManager = "cargo";
+    try {
+      const cargoContent = await _fsextra.readFile.call(void 0, 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 (e41) {
+    }
+  }
+  /**
+   * Analyze Go project
+   */
+  async analyzeGoProject(info) {
+    const goModPath = _path.join.call(void 0, this.workspaceRoot, "go.mod");
+    if (!await _fsextra.pathExists.call(void 0, goModPath)) {
+      return;
+    }
+    info.language = "Go";
+    info.packageManager = "go";
+    try {
+      const goModContent = await _fsextra.readFile.call(void 0, 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 (e42) {
+    }
+  }
+  /**
+   * Analyze Python project
+   */
+  async analyzePythonProject(info) {
+    const pyprojectPath = _path.join.call(void 0, this.workspaceRoot, "pyproject.toml");
+    const requirementsPath = _path.join.call(void 0, this.workspaceRoot, "requirements.txt");
+    const poetryLockPath = _path.join.call(void 0, this.workspaceRoot, "poetry.lock");
+    const pipfilePath = _path.join.call(void 0, this.workspaceRoot, "Pipfile");
+    const hasPyproject = await _fsextra.pathExists.call(void 0, pyprojectPath);
+    const hasRequirements = await _fsextra.pathExists.call(void 0, requirementsPath);
+    if (!hasPyproject && !hasRequirements) {
+      return;
+    }
+    info.language = "Python";
+    if (await _fsextra.pathExists.call(void 0, poetryLockPath)) {
+      info.packageManager = "poetry";
+    } else if (await _fsextra.pathExists.call(void 0, pipfilePath)) {
+      info.packageManager = "pipenv";
+    } else if (hasPyproject) {
+      info.packageManager = "pip";
+    } else {
+      info.packageManager = "pip";
+    }
+    let depsContent = "";
+    try {
+      if (hasRequirements) {
+        depsContent = await _fsextra.readFile.call(void 0, requirementsPath, "utf-8");
+      } else if (hasPyproject) {
+        depsContent = await _fsextra.readFile.call(void 0, 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 (e43) {
+    }
+  }
+};
+
+// 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 (_optionalChain([options, 'optionalAccess', _187 => _187.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
+
+
+
+
+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 = _nullishCoalesce(existingConfig, () => ( null));
+    this.state = {
+      currentStep: "welcome",
+      skipped: [],
+      completed: false
+    };
+  }
+  /**
+   * Run the full onboarding wizard
+   */
+  async run(options) {
+    if (!_optionalChain([options, 'optionalAccess', _188 => _188.force]) && this.isAlreadyConfigured()) {
+      return {
+        success: true,
+        config: {},
+        skippedSteps: ["welcome", "provider", "apiKey", "model", "telemetry", "preferences", "agentsFile"],
+        cancelled: false
+      };
+    }
+    try {
+      if (!_optionalChain([options, 'optionalAccess', _189 => _189.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 (!_optionalChain([options, 'optionalAccess', _190 => _190.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 = _chunkQMVTT55Ycjs.getProviderConfig.call(void 0, this.existingConfig, provider);
+    return providerConfig !== null;
+  }
+  /**
+   * Show welcome screen
+   */
+  async showWelcome() {
+    console.clear();
+    console.log(_chalk2.default.gray(ASCII_FRIEND));
+    console.log();
+    console.log(_chalk2.default.cyan.bold("  Welcome to Autohand!"));
+    console.log(_chalk2.default.gray("  Your super fast AI coding agent"));
+    console.log();
+    console.log(_chalk2.default.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.default.prompt({
+      type: "select",
+      name: "provider",
+      message: "Which LLM provider would you like to use?",
+      choices,
+      initial: _optionalChain([this, 'access', _191 => _191.existingConfig, 'optionalAccess', _192 => _192.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.default.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(_chalk2.default.gray(`
+  Get your API key at: ${this.getApiKeyUrl(provider)}
+`));
+    const result = await _enquirer2.default.prompt({
+      type: "password",
+      name: "apiKey",
+      message: `Enter your ${this.getProviderDisplayName(provider)} API key`,
+      validate: (val) => {
+        const v = val;
+        if (!_optionalChain([v, 'optionalAccess', _193 => _193.trim, 'call', _194 => _194()])) 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.default.prompt({
+      type: "input",
+      name: "model",
+      message: "Enter model ID",
+      initial: defaultModel,
+      validate: (val) => {
+        const v = val;
+        return _optionalChain([v, 'optionalAccess', _195 => _195.trim, 'call', _196 => _196()]) ? 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(_chalk2.default.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(_chalk2.default.white.bold("  Help us improve Autohand"));
+    console.log(_chalk2.default.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(_chalk2.default.gray("  We collect anonymous usage data to understand how"));
+    console.log(_chalk2.default.gray("  Autohand is used and where we can make it better."));
+    console.log();
+    console.log(_chalk2.default.gray("  What we collect:"));
+    console.log(_chalk2.default.gray("  - Command usage (which features are popular)"));
+    console.log(_chalk2.default.gray("  - Error rates (to fix bugs faster)"));
+    console.log(_chalk2.default.gray("  - Performance metrics (to speed things up)"));
+    console.log();
+    console.log(_chalk2.default.gray("  What we never collect:"));
+    console.log(_chalk2.default.gray("  - Your code or file contents"));
+    console.log(_chalk2.default.gray("  - API keys or credentials"));
+    console.log(_chalk2.default.gray("  - Personal information"));
+    console.log();
+    const { telemetryEnabled } = await _enquirer2.default.prompt({
+      type: "confirm",
+      name: "telemetryEnabled",
+      message: "Share anonymous usage data to help improve Autohand?",
+      initial: true
+    });
+    this.state.telemetryEnabled = telemetryEnabled;
+    if (telemetryEnabled) {
+      console.log(_chalk2.default.green("  Thanks for helping us improve Autohand!"));
+    } else {
+      console.log(_chalk2.default.gray("  No problem! You can change this anytime in config."));
+    }
+  }
+  /**
+   * Prompt for additional preferences
+   */
+  async promptPreferences() {
+    this.state.currentStep = "preferences";
+    const { configurePrefs } = await _enquirer2.default.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.default.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.default.prompt({
+      type: "confirm",
+      name: "autoConfirm",
+      message: "Auto-confirm non-destructive actions?",
+      initial: false
+    });
+    const { checkForUpdates: checkForUpdates2 } = await _enquirer2.default.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 = _path.join.call(void 0, this.workspaceRoot, "AGENTS.md");
+    const exists = await _fsextra.pathExists.call(void 0, agentsPath);
+    if (exists) {
+      const { overwrite } = await _enquirer2.default.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(_chalk2.default.gray("  Keeping existing AGENTS.md"));
+        return;
+      }
+    } else {
+      console.log();
+      console.log(_chalk2.default.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(_chalk2.default.white.bold("  Project Configuration"));
+      console.log(_chalk2.default.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(_chalk2.default.gray("  AGENTS.md helps Autohand understand your project better."));
+      console.log(_chalk2.default.gray("  It contains instructions specific to your codebase."));
+      console.log();
+      const { createAgents } = await _enquirer2.default.prompt({
+        type: "confirm",
+        name: "createAgents",
+        message: "Generate AGENTS.md based on your project?",
+        initial: true
+      });
+      if (!createAgents) {
+        this.state.skipped.push("agentsFile");
+        console.log(_chalk2.default.gray("  You can create it later with /init"));
+        return;
+      }
+    }
+    console.log();
+    console.log(_chalk2.default.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(_chalk2.default.gray("  Detected:"));
+      if (projectInfo.language) {
+        console.log(_chalk2.default.white(`  - Language: ${projectInfo.language}`));
+      }
+      if (projectInfo.framework) {
+        console.log(_chalk2.default.white(`  - Framework: ${projectInfo.framework}`));
+      }
+      if (projectInfo.packageManager) {
+        console.log(_chalk2.default.white(`  - Package manager: ${projectInfo.packageManager}`));
+      }
+      if (projectInfo.testFramework) {
+        console.log(_chalk2.default.white(`  - Test framework: ${projectInfo.testFramework}`));
+      }
+    }
+    const generator = new AgentsGenerator();
+    const content = generator.generateContent(projectInfo);
+    await _fsextra.writeFile.call(void 0, agentsPath, content);
+    this.state.agentsFileCreated = true;
+    console.log();
+    console.log(_chalk2.default.green("  Created AGENTS.md"));
+    console.log(_chalk2.default.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: _nullishCoalesce(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(_chalk2.default.green("  Setup complete!"));
+    console.log();
+    console.log(_chalk2.default.gray("  What was created:"));
+    console.log(_chalk2.default.white("  - ~/.autohand/config.json (your settings)"));
+    if (this.state.agentsFileCreated) {
+      console.log(_chalk2.default.white("  - AGENTS.md (project instructions for Autohand)"));
+    }
+    console.log();
+    console.log(_chalk2.default.gray("  Quick tips:"));
+    console.log(_chalk2.default.white("  - Type your request and press Enter to start"));
+    console.log(_chalk2.default.white("  - Use @filename to mention files"));
+    console.log(_chalk2.default.white("  - Type /help for all commands"));
+    console.log(_chalk2.default.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 _optionalChain([config, 'optionalAccess', _197 => _197.apiKey]) || null;
+  }
+  isCancellation(error) {
+    if (error && typeof error === "object") {
+      const e = error;
+      return e.code === "ERR_USE_AFTER_CLOSE" || _optionalChain([e, 'access', _198 => _198.message, 'optionalAccess', _199 => _199.includes, 'call', _200 => _200("cancelled")]) || _optionalChain([e, 'access', _201 => _201.message, 'optionalAccess', _202 => _202.includes, 'call', _203 => _203("canceled")]);
+    }
+    return false;
+  }
+  async pressEnter() {
+    console.log(_chalk2.default.gray("  Press Enter to continue..."));
+    await _enquirer2.default.prompt({
+      type: "invisible",
+      name: "continue",
+      message: ""
+    });
+  }
+};
+
+// src/core/agents/AgentDelegator.ts
+
+
+// src/core/agents/SubAgent.ts
+
+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 = _optionalChain([def, 'access', _204 => _204.parameters, 'optionalAccess', _205 => _205.properties]) ? Object.entries(def.parameters.properties).map(([name, prop]) => {
+      const required = _optionalChain([def, 'access', _206 => _206.parameters, 'optionalAccess', _207 => _207.required, 'optionalAccess', _208 => _208.includes, 'call', _209 => _209(name)]) ? "" : "?";
+      return `${name}${required}: ${prop.type}`;
+    }).join(", ") : "";
+    return `- ${def.name}(${params}): ${def.description}`;
+  }
+  async run(task) {
+    console.log(_chalk2.default.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 (_optionalChain([completion, 'access', _210 => _210.toolCalls, 'optionalAccess', _211 => _211.length])) {
+        this.conversation.addMessage({
+          role: "assistant",
+          content: completion.content || ""
+        });
+      } else {
+        this.conversation.addMessage({ role: "assistant", content: completion.content });
+      }
+      if (payload.thought) {
+        console.log(_chalk2.default.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 = _optionalChain([completion, 'access', _212 => _212.toolCalls, 'optionalAccess', _213 => _213[j]]);
+          const content = result.success ? _nullishCoalesce(result.output, () => ( "(no output)")) : _nullishCoalesce(result.error, () => ( "Tool failed"));
+          this.conversation.addMessage({
+            role: "tool",
+            name: result.tool,
+            content,
+            tool_call_id: _optionalChain([toolCall, 'optionalAccess', _214 => _214.id])
+          });
+          if (!result.success) {
+            console.log(_chalk2.default.red(`[${this.name}] Tool ${result.tool} failed: ${content}`));
+          }
+        }
+        continue;
+      }
+      const response = _nullishCoalesce(_nullishCoalesce(payload.finalResponse, () => ( payload.response)), () => ( completion.content));
+      console.log(_chalk2.default.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 {
       return JSON.parse(json);
-    } catch (e36) {
+    } catch (e44) {
       return {};
     }
   }
@@ -9092,7 +10174,7 @@ var SubAgent = class {
         return { finalResponse: contentValue };
       }
       return { finalResponse: raw.trim() };
-    } catch (e37) {
+    } catch (e45) {
       return { finalResponse: raw.trim() };
     }
   }
@@ -9293,7 +10375,7 @@ var ErrorLogger = class {
         used: totalMem - freeMem
       },
       cpu: {
-        model: _optionalChain([cpus, 'access', _196 => _196[0], 'optionalAccess', _197 => _197.model]) || "Unknown",
+        model: _optionalChain([cpus, 'access', _215 => _215[0], 'optionalAccess', _216 => _216.model]) || "Unknown",
         cores: cpus.length
       },
       hostname: _os2.default.hostname(),
@@ -9309,12 +10391,12 @@ var ErrorLogger = class {
       const entries = content.split("\n---\n").filter((entry) => entry.trim()).map((entry) => {
         try {
           return JSON.parse(entry);
-        } catch (e38) {
+        } catch (e46) {
           return null;
         }
       }).filter((entry) => entry !== null);
       return entries.slice(-count);
-    } catch (e39) {
+    } catch (e47) {
       return [];
     }
   }
@@ -9338,7 +10420,7 @@ var DEFAULT_CONFIG = {
   timeout: 5e3,
   maxRetries: 3,
   offlineQueue: true,
-  cliVersion: _chunkXJZYEURAcjs.package_default.version
+  cliVersion: _chunkJYTXG6OVcjs.package_default.version
 };
 var FeedbackApiClient = class {
   constructor(configOverrides) {
@@ -9360,13 +10442,13 @@ var FeedbackApiClient = class {
         this.deviceId = (await _fsextra2.default.readFile(this.deviceIdPath, "utf8")).trim();
         return this.deviceId;
       }
-    } catch (e40) {
+    } catch (e48) {
     }
     this.deviceId = `anon_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
     try {
       await _fsextra2.default.ensureDir(path17.default.dirname(this.deviceIdPath));
       await _fsextra2.default.writeFile(this.deviceIdPath, this.deviceId);
-    } catch (e41) {
+    } catch (e49) {
     }
     return this.deviceId;
   }
@@ -9466,7 +10548,7 @@ var FeedbackApiClient = class {
       }
       await _fsextra2.default.ensureDir(path17.default.dirname(this.queuePath));
       await _fsextra2.default.writeJson(this.queuePath, queue, { spaces: 2 });
-    } catch (e42) {
+    } catch (e50) {
     }
   }
   /**
@@ -9496,7 +10578,7 @@ var FeedbackApiClient = class {
             remaining.push(item);
             failed++;
           }
-        } catch (e43) {
+        } catch (e51) {
           item.attempts++;
           item.lastAttempt = (/* @__PURE__ */ new Date()).toISOString();
           remaining.push(item);
@@ -9508,7 +10590,7 @@ var FeedbackApiClient = class {
       } else {
         await _fsextra2.default.remove(this.queuePath);
       }
-    } catch (e44) {
+    } catch (e52) {
     }
     return { sent, failed };
   }
@@ -9523,9 +10605,9 @@ var FeedbackApiClient = class {
       const queue = await _fsextra2.default.readJson(this.queuePath);
       return {
         pending: queue.length,
-        oldestItem: _optionalChain([queue, 'access', _198 => _198[0], 'optionalAccess', _199 => _199.lastAttempt]) || null
+        oldestItem: _optionalChain([queue, 'access', _217 => _217[0], 'optionalAccess', _218 => _218.lastAttempt]) || null
       };
-    } catch (e45) {
+    } catch (e53) {
       return { pending: 0, oldestItem: null };
     }
   }
@@ -9543,7 +10625,7 @@ var FeedbackApiClient = class {
       });
       clearTimeout(timeoutId);
       return response.ok;
-    } catch (e46) {
+    } catch (e54) {
       return false;
     }
   }
@@ -9602,7 +10684,7 @@ var FeedbackManager = class {
       if (_fsextra2.default.existsSync(this.statePath)) {
         return _fsextra2.default.readJsonSync(this.statePath);
       }
-    } catch (e47) {
+    } catch (e55) {
     }
     return {
       lastPromptedAt: null,
@@ -9616,11 +10698,13 @@ var FeedbackManager = class {
     };
   }
   saveState() {
-    try {
-      _fsextra2.default.ensureDirSync(this.stateDir);
-      _fsextra2.default.writeJsonSync(this.statePath, this.state, { spaces: 2 });
-    } catch (e48) {
-    }
+    setImmediate(() => {
+      try {
+        _fsextra2.default.ensureDirSync(this.stateDir);
+        _fsextra2.default.writeJsonSync(this.statePath, this.state, { spaces: 2 });
+      } catch (e56) {
+      }
+    });
   }
   async saveFeedbackResponse(response) {
     try {
@@ -9631,12 +10715,12 @@ var FeedbackManager = class {
       }
       responses.push(response);
       _fsextra2.default.writeJsonSync(this.responsesPath, responses, { spaces: 2 });
-    } catch (e49) {
+    } catch (e57) {
     }
     if (this.config.sendToApi) {
       try {
         await this.apiClient.submit(response);
-      } catch (e50) {
+      } catch (e58) {
       }
     }
   }
@@ -9733,26 +10817,63 @@ var FeedbackManager = class {
       try {
         return await _enquirer2.default.prompt(config);
       } catch (error) {
-        if (_optionalChain([error, 'optionalAccess', _200 => _200.code]) === "ERR_USE_AFTER_CLOSE") {
+        if (_optionalChain([error, 'optionalAccess', _219 => _219.code]) === "ERR_USE_AFTER_CLOSE") {
           return null;
         }
         throw error;
       }
     };
     try {
-      const npsResult = await safePrompt({
-        type: "select",
+      const { Select } = _enquirer2.default;
+      const ratingChoices = [
+        { name: "5", message: `${_chalk2.default.green("5")} - Excellent` },
+        { name: "4", message: `${_chalk2.default.green("4")} - Good` },
+        { name: "3", message: `${_chalk2.default.yellow("3")} - Okay` },
+        { name: "2", message: `${_chalk2.default.red("2")} - Poor` },
+        { name: "1", message: `${_chalk2.default.red("1")} - Very Poor` },
+        { name: "skip", message: `${_chalk2.default.gray("s")} - Skip` }
+      ];
+      const ratingPrompt = new Select({
         name: "score",
-        message: "How would you rate your experience?",
-        choices: [
-          { name: "5", message: `${_chalk2.default.green("5")} - Excellent` },
-          { name: "4", message: `${_chalk2.default.green("4")} - Good` },
-          { name: "3", message: `${_chalk2.default.yellow("3")} - Okay` },
-          { name: "2", message: `${_chalk2.default.red("2")} - Poor` },
-          { name: "1", message: `${_chalk2.default.red("1")} - Very Poor` },
-          { name: "skip", message: `${_chalk2.default.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 (_optionalChain([error, 'optionalAccess', _220 => _220.code]) === "ERR_USE_AFTER_CLOSE") {
+          npsResult = null;
+        } else {
+          throw error;
+        }
+      }
       if (!npsResult) {
         this.state.dismissed++;
         this.saveState();
@@ -9774,7 +10895,7 @@ var FeedbackManager = class {
           name: "reason",
           message: "What do you like most about Autohand? (optional, press Enter to skip)"
         });
-        reason = _optionalChain([followUp, 'optionalAccess', _201 => _201.reason]) || void 0;
+        reason = _optionalChain([followUp, 'optionalAccess', _221 => _221.reason]) || void 0;
         if (followUp) {
           const recResult = await safePrompt({
             type: "confirm",
@@ -9782,7 +10903,7 @@ var FeedbackManager = class {
             message: "Would you recommend Autohand to a colleague?",
             initial: true
           });
-          recommend = _optionalChain([recResult, 'optionalAccess', _202 => _202.recommend]);
+          recommend = _optionalChain([recResult, 'optionalAccess', _222 => _222.recommend]);
         }
       } else {
         const followUp = await safePrompt({
@@ -9790,7 +10911,7 @@ var FeedbackManager = class {
           name: "improvement",
           message: "What could we do better? (optional, press Enter to skip)"
         });
-        improvement = _optionalChain([followUp, 'optionalAccess', _203 => _203.improvement]) || void 0;
+        improvement = _optionalChain([followUp, 'optionalAccess', _223 => _223.improvement]) || void 0;
       }
       const response = {
         npsScore,
@@ -9817,7 +10938,7 @@ var FeedbackManager = class {
       console.log();
       return true;
     } catch (error) {
-      if (_optionalChain([error, 'optionalAccess', _204 => _204.code]) === "ERR_USE_AFTER_CLOSE") {
+      if (_optionalChain([error, 'optionalAccess', _224 => _224.code]) === "ERR_USE_AFTER_CLOSE") {
         return false;
       }
       this.state.dismissed++;
@@ -9899,7 +11020,7 @@ var FeedbackManager = class {
       if (_fsextra2.default.existsSync(this.responsesPath)) {
         return _fsextra2.default.readJsonSync(this.responsesPath);
       }
-    } catch (e51) {
+    } catch (e59) {
     }
     return [];
   }
@@ -9950,7 +11071,7 @@ var TelemetryClient = class {
       const id = _crypto2.default.randomUUID();
       _fsextra2.default.writeFileSync(DEVICE_ID_FILE, id);
       return id;
-    } catch (e52) {
+    } catch (e60) {
       return _crypto2.default.randomUUID();
     }
   }
@@ -9964,7 +11085,7 @@ var TelemetryClient = class {
         const data = _fsextra2.default.readFileSync(QUEUE_FILE, "utf8");
         this.queue = JSON.parse(data);
       }
-    } catch (e53) {
+    } catch (e61) {
       this.queue = [];
     }
   }
@@ -9975,7 +11096,7 @@ var TelemetryClient = class {
     try {
       _fsextra2.default.ensureDirSync(TELEMETRY_DIR);
       _fsextra2.default.writeFileSync(QUEUE_FILE, JSON.stringify(this.queue, null, 2));
-    } catch (e54) {
+    } catch (e62) {
     }
   }
   /**
@@ -10018,7 +11139,7 @@ var TelemetryClient = class {
       });
       clearTimeout(timeout);
       return response.ok;
-    } catch (e55) {
+    } catch (e63) {
       return false;
     }
   }
@@ -10068,7 +11189,7 @@ var TelemetryClient = class {
             headers: {
               "Content-Type": "application/json",
               "Authorization": `Bearer ${authToken}`,
-              "X-CLI-Version": _optionalChain([eventsToSend, 'access', _205 => _205[0], 'optionalAccess', _206 => _206.cliVersion]) || "unknown"
+              "X-CLI-Version": _optionalChain([eventsToSend, 'access', _225 => _225[0], 'optionalAccess', _226 => _226.cliVersion]) || "unknown"
             },
             body: JSON.stringify({ events: eventsToSend })
           });
@@ -10080,7 +11201,7 @@ var TelemetryClient = class {
           } else {
             failed = eventsToSend.length;
           }
-        } catch (e56) {
+        } catch (e64) {
           failed = eventsToSend.length;
           await new Promise((resolve) => setTimeout(resolve, 1e3 * (attempt + 1)));
         }
@@ -10135,7 +11256,7 @@ var TelemetryClient = class {
         }
         _fsextra2.default.writeFileSync(syncQueueFile, JSON.stringify(syncQueue, null, 2));
         return { success: false, error: "Offline - queued for sync" };
-      } catch (e57) {
+      } catch (e65) {
         return { success: false, error: "Failed to queue session" };
       }
     }
@@ -10193,7 +11314,7 @@ var TelemetryClient = class {
         _fsextra2.default.removeSync(syncQueueFile);
       }
       return { synced, failed };
-    } catch (e58) {
+    } catch (e66) {
       return { synced: 0, failed: 0 };
     }
   }
@@ -10239,7 +11360,7 @@ var TelemetryManager = class {
    */
   getSystemInfo() {
     return {
-      cliVersion: _chunkXJZYEURAcjs.package_default.version,
+      cliVersion: _chunkJYTXG6OVcjs.package_default.version,
       platform: process.platform,
       osVersion: _os2.default.release(),
       nodeVersion: process.version,
@@ -10315,7 +11436,7 @@ var TelemetryManager = class {
    */
   async trackError(data) {
     this.errorsCount++;
-    const sanitizedStack = _optionalChain([data, 'access', _207 => _207.stack, 'optionalAccess', _208 => _208.replace, 'call', _209 => _209(/\/Users\/[^/]+/g, "/Users/***"), 'access', _210 => _210.replace, 'call', _211 => _211(/\/home\/[^/]+/g, "/home/***"), 'access', _212 => _212.replace, 'call', _213 => _213(/C:\\Users\\[^\\]+/g, "C:\\Users\\***")]);
+    const sanitizedStack = _optionalChain([data, 'access', _227 => _227.stack, 'optionalAccess', _228 => _228.replace, 'call', _229 => _229(/\/Users\/[^/]+/g, "/Users/***"), 'access', _230 => _230.replace, 'call', _231 => _231(/\/home\/[^/]+/g, "/home/***"), 'access', _232 => _232.replace, 'call', _233 => _233(/C:\\Users\\[^\\]+/g, "C:\\Users\\***")]);
     await this.trackEvent("error", {
       type: data.type,
       message: data.message,
@@ -10329,7 +11450,7 @@ var TelemetryManager = class {
    */
   async trackSessionFailureBug(data) {
     this.errorsCount++;
-    const sanitizedStack = _optionalChain([data, 'access', _214 => _214.error, 'access', _215 => _215.stack, 'optionalAccess', _216 => _216.replace, 'call', _217 => _217(/\/Users\/[^/]+/g, "/Users/***"), 'access', _218 => _218.replace, 'call', _219 => _219(/\/home\/[^/]+/g, "/home/***"), 'access', _220 => _220.replace, 'call', _221 => _221(/C:\\Users\\[^\\]+/g, "C:\\Users\\***")]);
+    const sanitizedStack = _optionalChain([data, 'access', _234 => _234.error, 'access', _235 => _235.stack, 'optionalAccess', _236 => _236.replace, 'call', _237 => _237(/\/Users\/[^/]+/g, "/Users/***"), 'access', _238 => _238.replace, 'call', _239 => _239(/\/home\/[^/]+/g, "/home/***"), 'access', _240 => _240.replace, 'call', _241 => _241(/C:\\Users\\[^\\]+/g, "C:\\Users\\***")]);
     const bugData = {
       type: "BUG:session_failure",
       errorMessage: data.error.message,
@@ -10407,10 +11528,10 @@ var TelemetryManager = class {
       metadata: {
         model: this.currentModel || void 0,
         provider: this.currentProvider || void 0,
-        totalTokens: _optionalChain([data, 'access', _222 => _222.metadata, 'optionalAccess', _223 => _223.totalTokens]),
-        startTime: _optionalChain([this, 'access', _224 => _224.sessionStartTime, 'optionalAccess', _225 => _225.toISOString, 'call', _226 => _226()]),
+        totalTokens: _optionalChain([data, 'access', _242 => _242.metadata, 'optionalAccess', _243 => _243.totalTokens]),
+        startTime: _optionalChain([this, 'access', _244 => _244.sessionStartTime, 'optionalAccess', _245 => _245.toISOString, 'call', _246 => _246()]),
         endTime: (/* @__PURE__ */ new Date()).toISOString(),
-        workspaceRoot: _optionalChain([data, 'access', _227 => _227.metadata, 'optionalAccess', _228 => _228.workspaceRoot])
+        workspaceRoot: _optionalChain([data, 'access', _247 => _247.metadata, 'optionalAccess', _248 => _248.workspaceRoot])
       }
     });
   }
@@ -10489,7 +11610,7 @@ var CommunitySkillsClient = class {
       if (_fsextra2.default.existsSync(deviceIdPath)) {
         return _fsextra2.default.readFileSync(deviceIdPath, "utf-8").trim();
       }
-    } catch (e59) {
+    } catch (e67) {
     }
     return `anon_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
   }
@@ -10504,7 +11625,7 @@ var CommunitySkillsClient = class {
       if (_fsextra2.default.existsSync(queuePath)) {
         this.queue = _fsextra2.default.readJsonSync(queuePath);
       }
-    } catch (e60) {
+    } catch (e68) {
       this.queue = [];
     }
   }
@@ -10515,7 +11636,7 @@ var CommunitySkillsClient = class {
     try {
       _fsextra2.default.ensureDirSync(this.queueDir);
       _fsextra2.default.writeJsonSync(path17.default.join(this.queueDir, "queue.json"), this.queue);
-    } catch (e61) {
+    } catch (e69) {
     }
   }
   /**
@@ -10573,34 +11694,34 @@ var CommunitySkillsClient = class {
    */
   async listSkills(filters) {
     const params = new URLSearchParams();
-    if (_optionalChain([filters, 'optionalAccess', _229 => _229.languages, 'optionalAccess', _230 => _230.length])) {
+    if (_optionalChain([filters, 'optionalAccess', _249 => _249.languages, 'optionalAccess', _250 => _250.length])) {
       params.set("languages", filters.languages.join(","));
     }
-    if (_optionalChain([filters, 'optionalAccess', _231 => _231.frameworks, 'optionalAccess', _232 => _232.length])) {
+    if (_optionalChain([filters, 'optionalAccess', _251 => _251.frameworks, 'optionalAccess', _252 => _252.length])) {
       params.set("frameworks", filters.frameworks.join(","));
     }
-    if (_optionalChain([filters, 'optionalAccess', _233 => _233.patterns, 'optionalAccess', _234 => _234.length])) {
+    if (_optionalChain([filters, 'optionalAccess', _253 => _253.patterns, 'optionalAccess', _254 => _254.length])) {
       params.set("patterns", filters.patterns.join(","));
     }
-    if (_optionalChain([filters, 'optionalAccess', _235 => _235.search])) {
+    if (_optionalChain([filters, 'optionalAccess', _255 => _255.search])) {
       params.set("search", filters.search);
     }
-    if (_optionalChain([filters, 'optionalAccess', _236 => _236.curated])) {
+    if (_optionalChain([filters, 'optionalAccess', _256 => _256.curated])) {
       params.set("curated", "true");
     }
-    if (_optionalChain([filters, 'optionalAccess', _237 => _237.featured])) {
+    if (_optionalChain([filters, 'optionalAccess', _257 => _257.featured])) {
       params.set("featured", "true");
     }
-    if (_optionalChain([filters, 'optionalAccess', _238 => _238.limit])) {
+    if (_optionalChain([filters, 'optionalAccess', _258 => _258.limit])) {
       params.set("limit", String(filters.limit));
     }
-    if (_optionalChain([filters, 'optionalAccess', _239 => _239.offset])) {
+    if (_optionalChain([filters, 'optionalAccess', _259 => _259.offset])) {
       params.set("offset", String(filters.offset));
     }
     const query = params.toString();
     const endpoint = `/v1/community-skills${query ? `?${query}` : ""}`;
     const result = await this.request(endpoint);
-    return result.ok ? _optionalChain([result, 'access', _240 => _240.data, 'optionalAccess', _241 => _241.skills]) || [] : [];
+    return result.ok ? _optionalChain([result, 'access', _260 => _260.data, 'optionalAccess', _261 => _261.skills]) || [] : [];
   }
   /**
    * Download a skill by name
@@ -10609,7 +11730,7 @@ var CommunitySkillsClient = class {
     const result = await this.request(
       `/v1/community-skills/${encodeURIComponent(name)}/download`
     );
-    if (result.ok && _optionalChain([result, 'access', _242 => _242.data, 'optionalAccess', _243 => _243.skill])) {
+    if (result.ok && _optionalChain([result, 'access', _262 => _262.data, 'optionalAccess', _263 => _263.skill])) {
       return { success: true, skill: result.data.skill };
     }
     return { success: false, error: result.error || "Failed to download skill" };
@@ -10631,7 +11752,7 @@ var CommunitySkillsClient = class {
     const query = params.toString();
     const endpoint = `/v1/community-skills/suggestions${query ? `?${query}` : ""}`;
     const result = await this.request(endpoint);
-    return result.ok ? _optionalChain([result, 'access', _244 => _244.data, 'optionalAccess', _245 => _245.suggestions]) || [] : [];
+    return result.ok ? _optionalChain([result, 'access', _264 => _264.data, 'optionalAccess', _265 => _265.suggestions]) || [] : [];
   }
   /**
    * Submit a skill for community review
@@ -10641,17 +11762,17 @@ var CommunitySkillsClient = class {
       method: "POST",
       body: JSON.stringify(skill)
     });
-    if (result.ok && _optionalChain([result, 'access', _246 => _246.data, 'optionalAccess', _247 => _247.success])) {
+    if (result.ok && _optionalChain([result, 'access', _266 => _266.data, 'optionalAccess', _267 => _267.success])) {
       return {
         success: true,
         id: result.data.id,
         pending: result.data.pending
       };
     }
-    if (!result.ok && _optionalChain([result, 'access', _248 => _248.error, 'optionalAccess', _249 => _249.includes, 'call', _250 => _250("fetch")])) {
+    if (!result.ok && _optionalChain([result, 'access', _268 => _268.error, 'optionalAccess', _269 => _269.includes, 'call', _270 => _270("fetch")])) {
       this.addToQueue("submit", skill);
     }
-    return { success: false, error: result.error || _optionalChain([result, 'access', _251 => _251.data, 'optionalAccess', _252 => _252.error]) };
+    return { success: false, error: result.error || _optionalChain([result, 'access', _271 => _271.data, 'optionalAccess', _272 => _272.error]) };
   }
   // ============ Backup Operations ============
   /**
@@ -10668,7 +11789,7 @@ var CommunitySkillsClient = class {
         })
       }
     );
-    if (result.ok && _optionalChain([result, 'access', _253 => _253.data, 'optionalAccess', _254 => _254.backed])) {
+    if (result.ok && _optionalChain([result, 'access', _273 => _273.data, 'optionalAccess', _274 => _274.backed])) {
       return true;
     }
     this.addToQueue("backup", skill);
@@ -10690,8 +11811,8 @@ var CommunitySkillsClient = class {
     });
     if (result.ok) {
       return {
-        backed: _optionalChain([result, 'access', _255 => _255.data, 'optionalAccess', _256 => _256.backed]) || 0,
-        failed: _optionalChain([result, 'access', _257 => _257.data, 'optionalAccess', _258 => _258.skipped]) || 0
+        backed: _optionalChain([result, 'access', _275 => _275.data, 'optionalAccess', _276 => _276.backed]) || 0,
+        failed: _optionalChain([result, 'access', _277 => _277.data, 'optionalAccess', _278 => _278.skipped]) || 0
       };
     }
     for (const skill of skills) {
@@ -10706,7 +11827,7 @@ var CommunitySkillsClient = class {
     const result = await this.request(
       `/v1/skills-backup/${encodeURIComponent(this.deviceId)}`
     );
-    return result.ok ? _optionalChain([result, 'access', _259 => _259.data, 'optionalAccess', _260 => _260.backups]) || [] : [];
+    return result.ok ? _optionalChain([result, 'access', _279 => _279.data, 'optionalAccess', _280 => _280.backups]) || [] : [];
   }
   /**
    * Restore skills from backup
@@ -10764,7 +11885,7 @@ var CommunitySkillsClient = class {
             })
           }
         );
-        success = result.ok && (_optionalChain([result, 'access', _261 => _261.data, 'optionalAccess', _262 => _262.backed]) || 0) > 0;
+        success = result.ok && (_optionalChain([result, 'access', _281 => _281.data, 'optionalAccess', _282 => _282.backed]) || 0) > 0;
       } else if (op.type === "submit") {
         const result = await this.request(
           "/v1/community-skills",
@@ -10773,7 +11894,7 @@ var CommunitySkillsClient = class {
             body: JSON.stringify(op.payload)
           }
         );
-        success = result.ok && _optionalChain([result, 'access', _263 => _263.data, 'optionalAccess', _264 => _264.success]) === true;
+        success = result.ok && _optionalChain([result, 'access', _283 => _283.data, 'optionalAccess', _284 => _284.success]) === true;
       }
       if (success) {
         sent++;
@@ -10797,7 +11918,6 @@ var CommunitySkillsClient = class {
 
 // src/ui/persistentInput.ts
 
-
 var _events = require('events'); var _events2 = _interopRequireDefault(_events);
 
 // src/ui/terminalRegions.ts
@@ -10961,7 +12081,7 @@ var PersistentInput = class extends _events2.default {
       if (!this.isActive || this.isPaused) {
         return;
       }
-      if (_optionalChain([key, 'optionalAccess', _265 => _265.name]) === "return" || _optionalChain([key, 'optionalAccess', _266 => _266.name]) === "enter") {
+      if (_optionalChain([key, 'optionalAccess', _285 => _285.name]) === "return" || _optionalChain([key, 'optionalAccess', _286 => _286.name]) === "enter") {
         if (this.currentInput.trim()) {
           this.addToQueue(this.currentInput.trim());
           this.currentInput = "";
@@ -10971,7 +12091,7 @@ var PersistentInput = class extends _events2.default {
         }
         return;
       }
-      if (_optionalChain([key, 'optionalAccess', _267 => _267.name]) === "backspace") {
+      if (_optionalChain([key, 'optionalAccess', _287 => _287.name]) === "backspace") {
         if (this.currentInput.length > 0) {
           this.currentInput = this.currentInput.slice(0, -1);
           if (!this.silentMode) {
@@ -10980,15 +12100,15 @@ var PersistentInput = class extends _events2.default {
         }
         return;
       }
-      if (_optionalChain([key, 'optionalAccess', _268 => _268.name]) === "escape") {
+      if (_optionalChain([key, 'optionalAccess', _288 => _288.name]) === "escape") {
         this.emit("escape");
         return;
       }
-      if (_optionalChain([key, 'optionalAccess', _269 => _269.name]) === "c" && key.ctrl) {
+      if (_optionalChain([key, 'optionalAccess', _289 => _289.name]) === "c" && key.ctrl) {
         this.emit("ctrl-c");
         return;
       }
-      if (_optionalChain([key, 'optionalAccess', _270 => _270.ctrl]) || _optionalChain([key, 'optionalAccess', _271 => _271.meta])) {
+      if (_optionalChain([key, 'optionalAccess', _290 => _290.ctrl]) || _optionalChain([key, 'optionalAccess', _291 => _291.meta])) {
         return;
       }
       if (_str) {
@@ -11019,7 +12139,7 @@ var PersistentInput = class extends _events2.default {
     this.currentInput = "";
     this.isPaused = false;
     if (this.silentMode) {
-      _readline2.default.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 _events2.default {
       this.input.on("keypress", this.handleKeypress);
     } else {
       this.regions.enable();
-      _readline2.default.emitKeypressEvents(this.input);
+      safeEmitKeypressEvents(this.input);
       const supportsRaw = typeof this.input.setRawMode === "function";
       if (supportsRaw) {
         this.input.setRawMode(true);
@@ -11218,7 +12338,7 @@ function formatToolOutputForDisplay(options) {
   const { tool, content, charLimit, filePath, command, commandArgs } = options;
   const totalChars = content.length;
   if (tool === "run_command" && command) {
-    const fullCommand = _optionalChain([commandArgs, 'optionalAccess', _272 => _272.length]) ? `${command} ${commandArgs.join(" ")}` : command;
+    const fullCommand = _optionalChain([commandArgs, 'optionalAccess', _292 => _292.length]) ? `${command} ${commandArgs.join(" ")}` : command;
     const outputLines = content ? content.split("\n").length : 0;
     const truncatedContent = charLimit > 0 && totalChars > charLimit ? `${content.slice(0, charLimit)}
 ... (${totalChars} chars)` : content;
@@ -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);
   };
@@ -11366,14 +12492,14 @@ async function confirm(message, context) {
         message: "Enter alternative action (or empty to cancel)"
       });
       const altAnswer = await inputPrompt.run();
-      if (_optionalChain([altAnswer, 'optionalAccess', _273 => _273.trim, 'call', _274 => _274()])) {
+      if (_optionalChain([altAnswer, 'optionalAccess', _293 => _293.trim, 'call', _294 => _294()])) {
         confirm.lastAlternative = altAnswer.trim();
         return "alternative";
       }
       return false;
     }
     return false;
-  } catch (e62) {
+  } catch (e70) {
     return false;
   }
 }
@@ -11704,12 +12830,12 @@ var EnvironmentBootstrap = class {
    * @returns Bootstrap result with all steps
    */
   async run(workspaceRoot, options) {
-    if (!_optionalChain([options, 'optionalAccess', _275 => _275.force]) && this.isCacheValid()) {
+    if (!_optionalChain([options, 'optionalAccess', _295 => _295.force]) && this.isCacheValid()) {
       return this.lastResult;
     }
     const startTime = Date.now();
     const steps = [];
-    if (!_optionalChain([options, 'optionalAccess', _276 => _276.skipGitSync])) {
+    if (!_optionalChain([options, 'optionalAccess', _296 => _296.skipGitSync])) {
       steps.push(await this.gitSync(workspaceRoot));
     }
     const pm = await this.detectPackageManager(workspaceRoot);
@@ -11720,7 +12846,7 @@ var EnvironmentBootstrap = class {
         detail: `Detected: ${pm}`
       });
     }
-    if (pm && !_optionalChain([options, 'optionalAccess', _277 => _277.skipInstall])) {
+    if (pm && !_optionalChain([options, 'optionalAccess', _297 => _297.skipInstall])) {
       steps.push(await this.installDependencies(workspaceRoot, pm));
     }
     steps.push(await this.validateToolchain(workspaceRoot));
@@ -11756,7 +12882,7 @@ var EnvironmentBootstrap = class {
           }
         }
         return "npm";
-      } catch (e63) {
+      } catch (e71) {
         return null;
       }
     }
@@ -11794,7 +12920,7 @@ var EnvironmentBootstrap = class {
         try {
           await execAsync("git pull --ff-only", { cwd: root, timeout: 6e4 });
           step.detail = "Pulled latest changes";
-        } catch (e64) {
+        } catch (e72) {
           step.detail = "Behind remote (pull failed, may need manual merge)";
         }
       } else if (statusOutput.includes("Your branch is ahead")) {
@@ -11979,28 +13105,28 @@ var CodeQualityPipeline = class {
     const startTime = Date.now();
     const scripts = await this.detectScripts(workspaceRoot);
     const checks = [];
-    if (_optionalChain([options, 'optionalAccess', _278 => _278.autoFix]) && scripts.lint) {
+    if (_optionalChain([options, 'optionalAccess', _298 => _298.autoFix]) && scripts.lint) {
       await this.runAutoFix(workspaceRoot, scripts.lint);
     }
     const parallelChecks = [];
-    if (scripts.lint && !_optionalChain([options, 'optionalAccess', _279 => _279.skipLint])) {
+    if (scripts.lint && !_optionalChain([options, 'optionalAccess', _299 => _299.skipLint])) {
       parallelChecks.push(this.runCheck(workspaceRoot, "lint", "Lint", scripts.lint));
     }
-    if (scripts.typecheck && !_optionalChain([options, 'optionalAccess', _280 => _280.skipTypecheck])) {
+    if (scripts.typecheck && !_optionalChain([options, 'optionalAccess', _300 => _300.skipTypecheck])) {
       parallelChecks.push(this.runCheck(workspaceRoot, "typecheck", "Types", scripts.typecheck));
     }
     if (parallelChecks.length > 0) {
       const parallelResults = await Promise.all(parallelChecks);
       checks.push(...parallelResults);
     }
-    if (scripts.test && !_optionalChain([options, 'optionalAccess', _281 => _281.skipTest])) {
+    if (scripts.test && !_optionalChain([options, 'optionalAccess', _301 => _301.skipTest])) {
       let testCmd = scripts.test;
-      if (_optionalChain([options, 'optionalAccess', _282 => _282.testFilter])) {
+      if (_optionalChain([options, 'optionalAccess', _302 => _302.testFilter])) {
         testCmd = `${scripts.test} --grep "${options.testFilter}"`;
       }
       checks.push(await this.runCheck(workspaceRoot, "test", "Tests", testCmd));
     }
-    if (scripts.build && !_optionalChain([options, 'optionalAccess', _283 => _283.skipBuild])) {
+    if (scripts.build && !_optionalChain([options, 'optionalAccess', _303 => _303.skipBuild])) {
       checks.push(await this.runCheck(workspaceRoot, "build", "Build", scripts.build));
     }
     const passed = checks.every((c) => c.status === "passed" || c.status === "skipped");
@@ -12030,7 +13156,7 @@ var CodeQualityPipeline = class {
         test: this.findScript(scripts, this.scriptPatterns.test),
         build: this.findScript(scripts, this.scriptPatterns.build)
       };
-    } catch (e65) {
+    } catch (e73) {
       return {};
     }
   }
@@ -12095,7 +13221,7 @@ var CodeQualityPipeline = class {
       try {
         await execAsync2(`npm run ${fixScript}`, { cwd: root, timeout: 6e4 });
         return;
-      } catch (e66) {
+      } catch (e74) {
       }
     }
   }
@@ -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;
@@ -12211,7 +13339,7 @@ var AutohandAgent = class {
     this.sessionRetryCount = 0;
     const initialProvider = _nullishCoalesce(runtime.config.provider, () => ( "openrouter"));
     const providerSettings = _chunkQMVTT55Ycjs.getProviderConfig.call(void 0, runtime.config, initialProvider);
-    const model = _nullishCoalesce(_nullishCoalesce(runtime.options.model, () => ( _optionalChain([providerSettings, 'optionalAccess', _284 => _284.model]))), () => ( "unconfigured"));
+    const model = _nullishCoalesce(_nullishCoalesce(runtime.options.model, () => ( _optionalChain([providerSettings, 'optionalAccess', _304 => _304.model]))), () => ( "unconfigured"));
     this.contextWindow = getContextWindow(model);
     this.ignoreFilter = new GitIgnoreParser(runtime.workspaceRoot, []);
     this.conversation = ConversationManager.getInstance();
@@ -12255,7 +13383,7 @@ var AutohandAgent = class {
       onExploration: (entry) => this.recordExploration(entry),
       onToolOutput: (chunk) => this.handleToolOutput(chunk),
       toolsRegistry: this.toolsRegistry,
-      getRegisteredTools: () => _nullishCoalesce(_optionalChain([this, 'access', _285 => _285.toolManager, 'optionalAccess', _286 => _286.listDefinitions, 'call', _287 => _287()]), () => ( [])),
+      getRegisteredTools: () => _nullishCoalesce(_optionalChain([this, 'access', _305 => _305.toolManager, 'optionalAccess', _306 => _306.listDefinitions, 'call', _307 => _307()]), () => ( [])),
       memoryManager: this.memoryManager,
       permissionManager: this.permissionManager,
       onFileModified: () => this.markFilesModified(),
@@ -12267,7 +13395,7 @@ var AutohandAgent = class {
           permissionType: "tool_approval"
         });
         for (const result of results) {
-          if (_optionalChain([result, 'access', _288 => _288.response, 'optionalAccess', _289 => _289.decision])) {
+          if (_optionalChain([result, 'access', _308 => _308.response, 'optionalAccess', _309 => _309.decision])) {
             return {
               decision: result.response.decision,
               reason: result.response.reason,
@@ -12294,20 +13422,20 @@ var AutohandAgent = class {
         });
       }
     });
-    this.errorLogger = new ErrorLogger(_chunkXJZYEURAcjs.package_default.version);
+    this.errorLogger = new ErrorLogger(_chunkJYTXG6OVcjs.package_default.version);
     this.feedbackManager = new FeedbackManager({
-      apiBaseUrl: _optionalChain([runtime, 'access', _290 => _290.config, 'access', _291 => _291.api, 'optionalAccess', _292 => _292.baseUrl]) || "https://api.autohand.ai",
-      cliVersion: _chunkXJZYEURAcjs.package_default.version
+      apiBaseUrl: _optionalChain([runtime, 'access', _310 => _310.config, 'access', _311 => _311.api, 'optionalAccess', _312 => _312.baseUrl]) || "https://api.autohand.ai",
+      cliVersion: _chunkJYTXG6OVcjs.package_default.version
     });
     this.skillsRegistry = new (0, _chunkCVYEUA3Dcjs.SkillsRegistry)(_chunkXTHHDIBGcjs.AUTOHAND_PATHS.skills);
     this.telemetryManager = new TelemetryManager({
-      enabled: _optionalChain([runtime, 'access', _293 => _293.config, 'access', _294 => _294.telemetry, 'optionalAccess', _295 => _295.enabled]) === true,
-      apiBaseUrl: _optionalChain([runtime, 'access', _296 => _296.config, 'access', _297 => _297.telemetry, 'optionalAccess', _298 => _298.apiBaseUrl]) || "https://api.autohand.ai",
-      enableSessionSync: _optionalChain([runtime, 'access', _299 => _299.config, 'access', _300 => _300.telemetry, 'optionalAccess', _301 => _301.enableSessionSync]) === true
+      enabled: _optionalChain([runtime, 'access', _313 => _313.config, 'access', _314 => _314.telemetry, 'optionalAccess', _315 => _315.enabled]) === true,
+      apiBaseUrl: _optionalChain([runtime, 'access', _316 => _316.config, 'access', _317 => _317.telemetry, 'optionalAccess', _318 => _318.apiBaseUrl]) || "https://api.autohand.ai",
+      enableSessionSync: _optionalChain([runtime, 'access', _319 => _319.config, 'access', _320 => _320.telemetry, 'optionalAccess', _321 => _321.enableSessionSync]) === true
     });
     const communitySettings = _nullishCoalesce(runtime.config.communitySkills, () => ( {}));
     this.communityClient = new CommunitySkillsClient({
-      apiBaseUrl: _optionalChain([runtime, 'access', _302 => _302.config, 'access', _303 => _303.api, 'optionalAccess', _304 => _304.baseUrl]) || "https://api.autohand.ai",
+      apiBaseUrl: _optionalChain([runtime, 'access', _322 => _322.config, 'access', _323 => _323.api, 'optionalAccess', _324 => _324.baseUrl]) || "https://api.autohand.ai",
       enabled: communitySettings.enabled !== false
     });
     this.skillsRegistry.setTelemetryManager(this.telemetryManager);
@@ -12399,9 +13527,9 @@ var AutohandAgent = class {
       definitions: [...DEFAULT_TOOL_DEFINITIONS, ...delegationTools],
       clientContext
     });
-    this.sessionManager = new (0, _chunkUPR5PKX4cjs.SessionManager)();
+    this.sessionManager = new (0, _chunk67NJKV5Acjs.SessionManager)();
     this.projectManager = new ProjectManager();
-    this.useInkRenderer = _optionalChain([runtime, 'access', _305 => _305.config, 'access', _306 => _306.ui, 'optionalAccess', _307 => _307.useInkRenderer]) === true;
+    this.useInkRenderer = _optionalChain([runtime, 'access', _325 => _325.config, 'access', _326 => _326.ui, 'optionalAccess', _327 => _327.useInkRenderer]) === true;
     this.persistentInput = createPersistentInput({
       maxQueueSize: 10,
       silentMode: true
@@ -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 _nullishCoalesce(sessionMgr.getCurrentSession(), () => ( void 0));
+      }
+    };
+    this.slashHandler = new SlashCommandHandler(slashContext, SLASH_COMMANDS);
+  }
+  static {
+    this.WORKSPACE_FILES_CACHE_TTL = 5e3;
   }
   async runInteractive() {
     await this.sessionManager.initialize();
@@ -12451,7 +13588,7 @@ var AutohandAgent = class {
     await this.resetConversationContext();
     this.feedbackManager.startSession();
     const providerSettings = _chunkQMVTT55Ycjs.getProviderConfig.call(void 0, this.runtime.config, this.activeProvider);
-    const model = _nullishCoalesce(_nullishCoalesce(this.runtime.options.model, () => ( _optionalChain([providerSettings, 'optionalAccess', _308 => _308.model]))), () => ( "unconfigured"));
+    const model = _nullishCoalesce(_nullishCoalesce(this.runtime.options.model, () => ( _optionalChain([providerSettings, 'optionalAccess', _328 => _328.model]))), () => ( "unconfigured"));
     await this.sessionManager.createSession(this.runtime.workspaceRoot, model);
     const session = this.sessionManager.getCurrentSession();
     if (session) {
@@ -12462,7 +13599,7 @@ var AutohandAgent = class {
       );
     }
     await this.hookManager.executeHooks("session-start", {
-      sessionId: _optionalChain([session, 'optionalAccess', _309 => _309.metadata, 'access', _310 => _310.sessionId]),
+      sessionId: _optionalChain([session, 'optionalAccess', _329 => _329.metadata, 'access', _330 => _330.sessionId]),
       sessionType: "startup"
     });
     await this.runInteractiveLoop();
@@ -12479,7 +13616,7 @@ var AutohandAgent = class {
     await this.hookManager.initialize();
     await this.resetConversationContext();
     const providerSettings = _chunkQMVTT55Ycjs.getProviderConfig.call(void 0, this.runtime.config, this.activeProvider);
-    const model = _nullishCoalesce(_nullishCoalesce(this.runtime.options.model, () => ( _optionalChain([providerSettings, 'optionalAccess', _311 => _311.model]))), () => ( "unconfigured"));
+    const model = _nullishCoalesce(_nullishCoalesce(this.runtime.options.model, () => ( _optionalChain([providerSettings, 'optionalAccess', _331 => _331.model]))), () => ( "unconfigured"));
     await this.sessionManager.createSession(this.runtime.workspaceRoot, model);
     const session = this.sessionManager.getCurrentSession();
     if (session) {
@@ -12490,7 +13627,7 @@ var AutohandAgent = class {
       );
     }
     await this.hookManager.executeHooks("session-start", {
-      sessionId: _optionalChain([session, 'optionalAccess', _312 => _312.metadata, 'access', _313 => _313.sessionId]),
+      sessionId: _optionalChain([session, 'optionalAccess', _332 => _332.metadata, 'access', _333 => _333.sessionId]),
       sessionType: "startup"
     });
   }
@@ -12501,21 +13638,23 @@ var AutohandAgent = class {
     const turnDuration = Date.now() - turnStartTime;
     const session = this.sessionManager.getCurrentSession();
     await this.hookManager.executeHooks("stop", {
-      sessionId: _optionalChain([session, 'optionalAccess', _314 => _314.metadata, 'access', _315 => _315.sessionId]),
+      sessionId: _optionalChain([session, 'optionalAccess', _334 => _334.metadata, 'access', _335 => _335.sessionId]),
       turnDuration,
       tokensUsed: this.sessionTokensUsed
     });
-    if (_optionalChain([this, 'access', _316 => _316.runtime, 'access', _317 => _317.config, 'access', _318 => _318.ui, 'optionalAccess', _319 => _319.terminalBell]) !== false) {
+    this.ensureStdinReady();
+    if (_optionalChain([this, 'access', _336 => _336.runtime, 'access', _337 => _337.config, 'access', _338 => _338.ui, 'optionalAccess', _339 => _339.terminalBell]) !== false) {
       process.stdout.write("\x07");
     }
     if (this.runtime.options.autoCommit) {
       await this.performAutoCommit();
     }
     await this.hookManager.executeHooks("session-end", {
-      sessionId: _optionalChain([session, 'optionalAccess', _320 => _320.metadata, 'access', _321 => _321.sessionId]),
+      sessionId: _optionalChain([session, 'optionalAccess', _340 => _340.metadata, 'access', _341 => _341.sessionId]),
       sessionEndReason: "exit",
       duration: Date.now() - this.sessionStartedAt
     });
+    this.ensureStdinReady();
     await this.telemetryManager.endSession("completed");
   }
   /**
@@ -12586,7 +13725,7 @@ If lint or tests fail, report the issues but do NOT commit.`;
               id: tc.id,
               type: "function",
               function: {
-                name: tc.tool || _optionalChain([tc, 'access', _322 => _322.function, 'optionalAccess', _323 => _323.name]) || "unknown",
+                name: tc.tool || _optionalChain([tc, 'access', _342 => _342.function, 'optionalAccess', _343 => _343.name]) || "unknown",
                 arguments: typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args || {})
               }
             }));
@@ -12618,7 +13757,7 @@ If lint or tests fail, report the issues but do NOT commit.`;
         context: "resumeSession"
       });
       const providerSettings = _chunkQMVTT55Ycjs.getProviderConfig.call(void 0, this.runtime.config, this.activeProvider);
-      const model = _nullishCoalesce(_nullishCoalesce(this.runtime.options.model, () => ( _optionalChain([providerSettings, 'optionalAccess', _324 => _324.model]))), () => ( "unconfigured"));
+      const model = _nullishCoalesce(_nullishCoalesce(this.runtime.options.model, () => ( _optionalChain([providerSettings, 'optionalAccess', _344 => _344.model]))), () => ( "unconfigured"));
       await this.sessionManager.createSession(this.runtime.workspaceRoot, model);
       await this.runInteractiveLoop();
     }
@@ -12637,7 +13776,7 @@ If lint or tests fail, report the issues but do NOT commit.`;
               console.log(_chalk2.default.gray(`  ${remaining} more request(s) queued`));
             }
           }
-        } else if (_optionalChain([this, 'access', _325 => _325.inkRenderer, 'optionalAccess', _326 => _326.hasQueuedInstructions, 'call', _327 => _327()])) {
+        } else if (_optionalChain([this, 'access', _345 => _345.inkRenderer, 'optionalAccess', _346 => _346.hasQueuedInstructions, 'call', _347 => _347()])) {
           instruction = _nullishCoalesce(this.inkRenderer.dequeueInstruction(), () => ( null));
           if (instruction) {
             console.log(_chalk2.default.cyan(`
@@ -12669,7 +13808,7 @@ If lint or tests fail, report the issues but do NOT commit.`;
           const trigger = this.feedbackManager.shouldPrompt({ sessionEnding: true });
           if (trigger) {
             const session2 = this.sessionManager.getCurrentSession();
-            await this.feedbackManager.promptForFeedback(trigger, _optionalChain([session2, 'optionalAccess', _328 => _328.metadata, 'access', _329 => _329.sessionId]));
+            await this.feedbackManager.promptForFeedback(trigger, _optionalChain([session2, 'optionalAccess', _348 => _348.metadata, 'access', _349 => _349.sessionId]));
           }
           await this.closeSession();
           return;
@@ -12686,11 +13825,12 @@ If lint or tests fail, report the issues but do NOT commit.`;
         const turnDuration = Date.now() - turnStartTime;
         const session = this.sessionManager.getCurrentSession();
         await this.hookManager.executeHooks("stop", {
-          sessionId: _optionalChain([session, 'optionalAccess', _330 => _330.metadata, 'access', _331 => _331.sessionId]),
+          sessionId: _optionalChain([session, 'optionalAccess', _350 => _350.metadata, 'access', _351 => _351.sessionId]),
           turnDuration,
           tokensUsed: this.sessionTokensUsed
         });
-        if (_optionalChain([this, 'access', _332 => _332.runtime, 'access', _333 => _333.config, 'access', _334 => _334.ui, 'optionalAccess', _335 => _335.terminalBell]) !== false) {
+        this.ensureStdinReady();
+        if (_optionalChain([this, 'access', _352 => _352.runtime, 'access', _353 => _353.config, 'access', _354 => _354.ui, 'optionalAccess', _355 => _355.terminalBell]) !== false) {
           process.stdout.write("\x07");
         }
         this.feedbackManager.recordInteraction();
@@ -12704,13 +13844,13 @@ If lint or tests fail, report the issues but do NOT commit.`;
           if (feedbackTrigger === "gratitude") {
             await this.feedbackManager.quickRating();
           } else {
-            await this.feedbackManager.promptForFeedback(feedbackTrigger, _optionalChain([session2, 'optionalAccess', _336 => _336.metadata, 'access', _337 => _337.sessionId]));
+            await this.feedbackManager.promptForFeedback(feedbackTrigger, _optionalChain([session2, 'optionalAccess', _356 => _356.metadata, 'access', _357 => _357.sessionId]));
           }
         }
         console.log();
       } catch (error) {
         const errorObj = error;
-        const isCancel = errorObj.name === "ExitPromptError" || errorObj.isCanceled || _optionalChain([errorObj, 'access', _338 => _338.message, 'optionalAccess', _339 => _339.includes, 'call', _340 => _340("canceled")]) || _optionalChain([errorObj, 'access', _341 => _341.message, 'optionalAccess', _342 => _342.includes, 'call', _343 => _343("User force closed")]) || !errorObj.message;
+        const isCancel = errorObj.name === "ExitPromptError" || errorObj.isCanceled || _optionalChain([errorObj, 'access', _358 => _358.message, 'optionalAccess', _359 => _359.includes, 'call', _360 => _360("canceled")]) || _optionalChain([errorObj, 'access', _361 => _361.message, 'optionalAccess', _362 => _362.includes, 'call', _363 => _363("User force closed")]) || !errorObj.message;
         if (isCancel) {
           continue;
         }
@@ -12846,6 +13986,10 @@ If lint or tests fail, report the issues but do NOT commit.`;
     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 = _child_process.spawnSync.call(void 0, "git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
       cwd: this.runtime.workspaceRoot,
       encoding: "utf8"
@@ -12858,16 +14002,18 @@ 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) {
     let entries;
     try {
       entries = await _fsextra2.default.readdir(current);
-    } catch (e67) {
+    } catch (e75) {
       return;
     }
     for (const entry of entries) {
@@ -12883,7 +14029,7 @@ If lint or tests fail, report the issues but do NOT commit.`;
         } else if (stats.isFile()) {
           acc.push(rel);
         }
-      } catch (e68) {
+      } catch (e76) {
         continue;
       }
     }
@@ -12952,7 +14098,7 @@ ${selectedProvider} is not configured yet. Let's set it up!
       }
       await this.changeProviderModel(selectedProvider);
     } catch (error) {
-      if (error.name === "ExitPromptError" || _optionalChain([error, 'access', _344 => _344.message, 'optionalAccess', _345 => _345.includes, 'call', _346 => _346("canceled")])) {
+      if (error.name === "ExitPromptError" || _optionalChain([error, 'access', _364 => _364.message, 'optionalAccess', _365 => _365.includes, 'call', _366 => _366("canceled")])) {
         console.log(_chalk2.default.gray("\nConfiguration cancelled."));
         return;
       }
@@ -13014,7 +14160,7 @@ ${selectedProvider} is not configured yet. Let's set it up!
       this.resetLlmClient("openrouter", answers.model);
       console.log(_chalk2.default.green("\n\u2713 OpenRouter configured successfully!"));
     } catch (error) {
-      if (error.name === "ExitPromptError" || _optionalChain([error, 'access', _347 => _347.message, 'optionalAccess', _348 => _348.includes, 'call', _349 => _349("canceled")])) {
+      if (error.name === "ExitPromptError" || _optionalChain([error, 'access', _367 => _367.message, 'optionalAccess', _368 => _368.includes, 'call', _369 => _369("canceled")])) {
         console.log(_chalk2.default.gray("\nConfiguration cancelled."));
         return;
       }
@@ -13031,9 +14177,9 @@ ${selectedProvider} is not configured yet. Let's set it up!
         const response = await fetch(`${ollamaUrl}/api/tags`);
         if (response.ok) {
           const data = await response.json();
-          availableModels = _optionalChain([data, 'access', _350 => _350.models, 'optionalAccess', _351 => _351.map, 'call', _352 => _352((m) => m.name)]) || [];
+          availableModels = _optionalChain([data, 'access', _370 => _370.models, 'optionalAccess', _371 => _371.map, 'call', _372 => _372((m) => m.name)]) || [];
         }
-      } catch (e69) {
+      } catch (e77) {
         console.log(_chalk2.default.yellow("\u26A0 Could not connect to Ollama. Make sure it's running.\n"));
       }
       let modelAnswer;
@@ -13068,7 +14214,7 @@ ${selectedProvider} is not configured yet. Let's set it up!
       this.resetLlmClient("ollama", modelAnswer.model);
       console.log(_chalk2.default.green("\n\u2713 Ollama configured successfully!"));
     } catch (error) {
-      if (error.name === "ExitPromptError" || _optionalChain([error, 'access', _353 => _353.message, 'optionalAccess', _354 => _354.includes, 'call', _355 => _355("canceled")])) {
+      if (error.name === "ExitPromptError" || _optionalChain([error, 'access', _373 => _373.message, 'optionalAccess', _374 => _374.includes, 'call', _375 => _375("canceled")])) {
         console.log(_chalk2.default.gray("\nConfiguration cancelled."));
         return;
       }
@@ -13104,7 +14250,7 @@ ${selectedProvider} is not configured yet. Let's set it up!
       this.resetLlmClient("llamacpp", answers.model);
       console.log(_chalk2.default.green("\n\u2713 llama.cpp configured successfully!"));
     } catch (error) {
-      if (error.name === "ExitPromptError" || _optionalChain([error, 'access', _356 => _356.message, 'optionalAccess', _357 => _357.includes, 'call', _358 => _358("canceled")])) {
+      if (error.name === "ExitPromptError" || _optionalChain([error, 'access', _376 => _376.message, 'optionalAccess', _377 => _377.includes, 'call', _378 => _378("canceled")])) {
         console.log(_chalk2.default.gray("\nConfiguration cancelled."));
         return;
       }
@@ -13146,7 +14292,7 @@ ${selectedProvider} is not configured yet. Let's set it up!
       this.resetLlmClient("openai", answers.model);
       console.log(_chalk2.default.green("\n\u2713 OpenAI configured successfully!"));
     } catch (error) {
-      if (error.name === "ExitPromptError" || _optionalChain([error, 'access', _359 => _359.message, 'optionalAccess', _360 => _360.includes, 'call', _361 => _361("canceled")])) {
+      if (error.name === "ExitPromptError" || _optionalChain([error, 'access', _379 => _379.message, 'optionalAccess', _380 => _380.includes, 'call', _381 => _381("canceled")])) {
         console.log(_chalk2.default.gray("\nConfiguration cancelled."));
         return;
       }
@@ -13164,9 +14310,9 @@ ${selectedProvider} is not configured yet. Let's set it up!
         const response = await fetch(`${mlxUrl}/v1/models`);
         if (response.ok) {
           const data = await response.json();
-          availableModels = _optionalChain([data, 'access', _362 => _362.data, 'optionalAccess', _363 => _363.map, 'call', _364 => _364((m) => m.id)]) || [];
+          availableModels = _optionalChain([data, 'access', _382 => _382.data, 'optionalAccess', _383 => _383.map, 'call', _384 => _384((m) => m.id)]) || [];
         }
-      } catch (e70) {
+      } catch (e78) {
         console.log(_chalk2.default.yellow("\u26A0 Could not connect to MLX server. Make sure it's running.\n"));
       }
       let modelAnswer;
@@ -13199,7 +14345,7 @@ ${selectedProvider} is not configured yet. Let's set it up!
       this.resetLlmClient("mlx", modelAnswer.model);
       console.log(_chalk2.default.green("\n\u2713 MLX configured successfully!"));
     } catch (error) {
-      if (error.name === "ExitPromptError" || _optionalChain([error, 'access', _365 => _365.message, 'optionalAccess', _366 => _366.includes, 'call', _367 => _367("canceled")])) {
+      if (error.name === "ExitPromptError" || _optionalChain([error, 'access', _385 => _385.message, 'optionalAccess', _386 => _386.includes, 'call', _387 => _387("canceled")])) {
         console.log(_chalk2.default.gray("\nConfiguration cancelled."));
         return;
       }
@@ -13209,13 +14355,17 @@ ${selectedProvider} is not configured yet. Let's set it up!
   async changeProviderModel(provider) {
     try {
       const currentSettings = _chunkQMVTT55Ycjs.getProviderConfig.call(void 0, this.runtime.config, provider);
-      const currentModel = _nullishCoalesce(_nullishCoalesce(this.runtime.options.model, () => ( _optionalChain([currentSettings, 'optionalAccess', _368 => _368.model]))), () => ( ""));
-      if (provider === "ollama" && _optionalChain([currentSettings, 'optionalAccess', _369 => _369.baseUrl])) {
+      const currentModel = _nullishCoalesce(_nullishCoalesce(this.runtime.options.model, () => ( _optionalChain([currentSettings, 'optionalAccess', _388 => _388.model]))), () => ( ""));
+      if (provider === "openai" || provider === "openrouter") {
+        await this.changeCloudProviderSettings(provider, currentModel, currentSettings);
+        return;
+      }
+      if (provider === "ollama" && _optionalChain([currentSettings, 'optionalAccess', _389 => _389.baseUrl])) {
         try {
           const response = await fetch(`${currentSettings.baseUrl}/api/tags`);
           if (response.ok) {
             const data = await response.json();
-            const models = _optionalChain([data, 'access', _370 => _370.models, 'optionalAccess', _371 => _371.map, 'call', _372 => _372((m) => m.name)]) || [];
+            const models = _optionalChain([data, 'access', _390 => _390.models, 'optionalAccess', _391 => _391.map, 'call', _392 => _392((m) => m.name)]) || [];
             if (models.length > 0) {
               const answer2 = await _enquirer2.default.prompt([
                 {
@@ -13230,23 +14380,9 @@ ${selectedProvider} is not configured yet. Let's set it up!
               return;
             }
           }
-        } catch (e71) {
+        } catch (e79) {
         }
       }
-      if (provider === "openai") {
-        const models = ["gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-4", "gpt-3.5-turbo"];
-        const answer2 = await _enquirer2.default.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 _enquirer2.default.prompt([
         {
           type: "input",
@@ -13255,15 +14391,174 @@ ${selectedProvider} is not configured yet. Let's set it up!
           initial: currentModel
         }
       ]);
-      await this.applyModelChange(provider, _optionalChain([answer, 'access', _373 => _373.model, 'optionalAccess', _374 => _374.trim, 'call', _375 => _375()]), currentModel);
+      await this.applyModelChange(provider, _optionalChain([answer, 'access', _393 => _393.model, 'optionalAccess', _394 => _394.trim, 'call', _395 => _395()]), currentModel);
     } catch (error) {
-      if (error.name === "ExitPromptError" || _optionalChain([error, 'access', _376 => _376.message, 'optionalAccess', _377 => _377.includes, 'call', _378 => _378("canceled")])) {
+      if (error.name === "ExitPromptError" || _optionalChain([error, 'access', _396 => _396.message, 'optionalAccess', _397 => _397.includes, 'call', _398 => _398("canceled")])) {
         console.log(_chalk2.default.gray("\nModel change cancelled."));
         return;
       }
       throw error;
     }
   }
+  async changeCloudProviderSettings(provider, currentModel, currentSettings) {
+    const providerName = provider === "openai" ? "OpenAI" : "OpenRouter";
+    const maskedKey = _optionalChain([currentSettings, 'optionalAccess', _399 => _399.apiKey]) ? `...${currentSettings.apiKey.slice(-4)}` : "not set";
+    console.log(_chalk2.default.cyan(`
+${providerName} Settings`));
+    console.log(_chalk2.default.gray(`Current model: ${currentModel || "not set"}`));
+    console.log(_chalk2.default.gray(`Current API key: ${maskedKey}
+`));
+    const { action } = await _enquirer2.default.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 = _optionalChain([currentSettings, 'optionalAccess', _400 => _400.apiKey]) || "";
+    if (action === "apiKey" || action === "both") {
+      const keyUrl = provider === "openai" ? "https://platform.openai.com/api-keys" : "https://openrouter.ai/keys";
+      console.log(_chalk2.default.gray(`
+Get your API key at: ${keyUrl}
+`));
+      const { apiKey } = await _enquirer2.default.prompt([
+        {
+          type: "password",
+          name: "apiKey",
+          message: `Enter your ${providerName} API key`,
+          validate: (val) => {
+            const v = val;
+            if (!_optionalChain([v, 'optionalAccess', _401 => _401.trim, 'call', _402 => _402()])) return "API key is required";
+            if (v.length < 10) return "API key seems too short";
+            return true;
+          }
+        }
+      ]);
+      console.log(_chalk2.default.gray("\nValidating API key..."));
+      const validationResult = await this.validateApiKey(provider, apiKey.trim());
+      if (!validationResult.valid) {
+        console.log(_chalk2.default.red(`
+\u2717 ${validationResult.error}`));
+        console.log(_chalk2.default.gray(validationResult.hint || ""));
+        return;
+      }
+      console.log(_chalk2.default.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 _enquirer2.default.prompt([
+          {
+            type: "select",
+            name: "model",
+            message: "Select a model",
+            choices: models,
+            initial: Math.max(0, models.indexOf(currentModel))
+          }
+        ]);
+        newModel = model;
+      } else {
+        const { model } = await _enquirer2.default.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 _chunkQMVTT55Ycjs.saveConfig.call(void 0, this.runtime.config);
+    this.resetLlmClient(provider, newModel);
+    this.contextWindow = getContextWindow(newModel);
+    this.contextPercentLeft = 100;
+    this.emitStatus();
+    console.log(_chalk2.default.green(`
+\u2713 ${providerName} settings updated successfully!`));
+    console.log(_chalk2.default.gray(`  Provider: ${provider}`));
+    console.log(_chalk2.default.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 (e80) {
+      }
+      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: _optionalChain([errorData, 'optionalAccess', _403 => _403.error, 'optionalAccess', _404 => _404.message]) || `API returned status ${status}`,
+        hint: "Please verify your API key and try again."
+      };
+    } catch (error) {
+      const err = error;
+      if (_optionalChain([err, 'access', _405 => _405.message, 'optionalAccess', _406 => _406.includes, 'call', _407 => _407("fetch")]) || _optionalChain([err, 'access', _408 => _408.message, 'optionalAccess', _409 => _409.includes, 'call', _410 => _410("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(_chalk2.default.gray("Model unchanged."));
@@ -13309,12 +14604,28 @@ ${selectedProvider} is not configured yet. Let's set it up!
       console.log(_chalk2.default.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 _fsextra2.default.writeFile(target, template, "utf8");
-    console.log(_chalk2.default.green("Created AGENTS.md template. Customize it to guide the agent."));
+    console.log(_chalk2.default.gray("Analyzing project structure..."));
+    const analyzer = new ProjectAnalyzer(this.runtime.workspaceRoot);
+    const projectInfo = await analyzer.analyze();
+    if (Object.keys(projectInfo).length > 0) {
+      console.log(_chalk2.default.gray("Detected:"));
+      if (projectInfo.language) {
+        console.log(_chalk2.default.white(`  - Language: ${projectInfo.language}`));
+      }
+      if (projectInfo.framework) {
+        console.log(_chalk2.default.white(`  - Framework: ${projectInfo.framework}`));
+      }
+      if (projectInfo.packageManager) {
+        console.log(_chalk2.default.white(`  - Package manager: ${projectInfo.packageManager}`));
+      }
+      if (projectInfo.testFramework) {
+        console.log(_chalk2.default.white(`  - Test framework: ${projectInfo.testFramework}`));
+      }
+    }
+    const generator = new AgentsGenerator();
+    const content = generator.generateContent(projectInfo);
+    await _fsextra2.default.writeFile(target, content, "utf8");
+    console.log(_chalk2.default.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
@@ -13426,8 +14737,8 @@ No provider is configured yet. Let's set one up!
         return this.runInstruction(instruction);
       }
       const err = error instanceof Error ? error : new Error(String(error));
-      const maxRetries = _nullishCoalesce(_optionalChain([this, 'access', _379 => _379.runtime, 'access', _380 => _380.config, 'access', _381 => _381.agent, 'optionalAccess', _382 => _382.sessionRetryLimit]), () => ( 3));
-      const baseDelay = _nullishCoalesce(_optionalChain([this, 'access', _383 => _383.runtime, 'access', _384 => _384.config, 'access', _385 => _385.agent, 'optionalAccess', _386 => _386.sessionRetryDelay]), () => ( 1e3));
+      const maxRetries = _nullishCoalesce(_optionalChain([this, 'access', _411 => _411.runtime, 'access', _412 => _412.config, 'access', _413 => _413.agent, 'optionalAccess', _414 => _414.sessionRetryLimit]), () => ( 3));
+      const baseDelay = _nullishCoalesce(_optionalChain([this, 'access', _415 => _415.runtime, 'access', _416 => _416.config, 'access', _417 => _417.agent, 'optionalAccess', _418 => _418.sessionRetryDelay]), () => ( 1e3));
       if (this.isRetryableSessionError(err) && this.sessionRetryCount < maxRetries) {
         this.sessionRetryCount++;
         await this.submitSessionFailureBugReport(err, this.sessionRetryCount, maxRetries);
@@ -13468,7 +14779,7 @@ No provider is configured yet. Let's set one up!
       if (this.taskStartedAt && !canceledByUser && !this.useInkRenderer) {
         const elapsed = this.formatElapsedTime(this.taskStartedAt);
         const tokens = this.formatTokens(this.totalTokensUsed);
-        const queueCount = this.pendingInkInstructions.length + (_nullishCoalesce(_optionalChain([this, 'access', _387 => _387.inkRenderer, 'optionalAccess', _388 => _388.getQueueCount, 'call', _389 => _389()]), () => ( 0))) + this.persistentInput.getQueueLength();
+        const queueCount = this.pendingInkInstructions.length + (_nullishCoalesce(_optionalChain([this, 'access', _419 => _419.inkRenderer, 'optionalAccess', _420 => _420.getQueueCount, 'call', _421 => _421()]), () => ( 0))) + this.persistentInput.getQueueLength();
         const queueStatus = queueCount > 0 ? ` \xB7 ${queueCount} queued` : "";
         console.log(_chalk2.default.gray(`
 Completed in ${elapsed} \xB7 ${tokens} used${queueStatus}`));
@@ -13541,7 +14852,7 @@ Completed in ${elapsed} \xB7 ${tokens} used${queueStatus}`));
     const session = this.sessionManager.getCurrentSession();
     const sessionDuration = Date.now() - this.sessionStartedAt;
     await this.hookManager.executeHooks("session-end", {
-      sessionId: _optionalChain([session, 'optionalAccess', _390 => _390.metadata, 'access', _391 => _391.sessionId]),
+      sessionId: _optionalChain([session, 'optionalAccess', _422 => _422.metadata, 'access', _423 => _423.sessionId]),
       sessionEndReason: "quit",
       duration: sessionDuration
     });
@@ -13552,7 +14863,7 @@ Completed in ${elapsed} \xB7 ${tokens} used${queueStatus}`));
     }
     const messages = session.getMessages();
     const lastUserMsg = messages.filter((m) => m.role === "user").slice(-1)[0];
-    const summary = _optionalChain([lastUserMsg, 'optionalAccess', _392 => _392.content, 'access', _393 => _393.slice, 'call', _394 => _394(0, 60)]) || "Session complete";
+    const summary = _optionalChain([lastUserMsg, 'optionalAccess', _424 => _424.content, 'access', _425 => _425.slice, 'call', _426 => _426(0, 60)]) || "Session complete";
     const syncResult = await this.telemetryManager.syncSession({
       messages: messages.map((m) => ({
         role: m.role,
@@ -13575,15 +14886,15 @@ Completed in ${elapsed} \xB7 ${tokens} used${queueStatus}`));
 `));
   }
   async runReactLoop(abortController) {
-    const debugMode = _optionalChain([this, 'access', _395 => _395.runtime, 'access', _396 => _396.config, 'access', _397 => _397.agent, 'optionalAccess', _398 => _398.debug]) === true || process.env.AUTOHAND_DEBUG === "1";
+    const debugMode = _optionalChain([this, 'access', _427 => _427.runtime, 'access', _428 => _428.config, 'access', _429 => _429.agent, 'optionalAccess', _430 => _430.debug]) === true || process.env.AUTOHAND_DEBUG === "1";
     if (debugMode) process.stderr.write(`[AGENT DEBUG] runReactLoop started
 `);
-    const maxIterations = _nullishCoalesce(_optionalChain([this, 'access', _399 => _399.runtime, 'access', _400 => _400.config, 'access', _401 => _401.agent, 'optionalAccess', _402 => _402.maxIterations]), () => ( 100));
+    const maxIterations = _nullishCoalesce(_optionalChain([this, 'access', _431 => _431.runtime, 'access', _432 => _432.config, 'access', _433 => _433.agent, 'optionalAccess', _434 => _434.maxIterations]), () => ( 100));
     const allTools = this.toolManager.toFunctionDefinitions();
     if (debugMode) process.stderr.write(`[AGENT DEBUG] Loaded ${allTools.length} tools, maxIterations=${maxIterations}
 `);
     this.startStatusUpdates();
-    const showThinking = _optionalChain([this, 'access', _403 => _403.runtime, 'access', _404 => _404.config, 'access', _405 => _405.ui, 'optionalAccess', _406 => _406.showThinking]) !== false;
+    const showThinking = _optionalChain([this, 'access', _435 => _435.runtime, 'access', _436 => _436.config, 'access', _437 => _437.ui, 'optionalAccess', _438 => _438.showThinking]) !== false;
     for (let iteration = 0; iteration < maxIterations; iteration += 1) {
       if (abortController.signal.aborted) {
         if (debugMode) process.stderr.write("[AGENT DEBUG] Abort detected at loop start, breaking\n");
@@ -13591,14 +14902,14 @@ Completed in ${elapsed} \xB7 ${tokens} used${queueStatus}`));
       }
       const messages = this.conversation.history();
       const tools = filterToolsByRelevance(allTools, messages);
-      const model = _nullishCoalesce(_nullishCoalesce(this.runtime.options.model, () => ( _optionalChain([_chunkQMVTT55Ycjs.getProviderConfig.call(void 0, this.runtime.config, this.activeProvider), 'optionalAccess', _407 => _407.model]))), () => ( "unconfigured"));
+      const model = _nullishCoalesce(_nullishCoalesce(this.runtime.options.model, () => ( _optionalChain([_chunkQMVTT55Ycjs.getProviderConfig.call(void 0, this.runtime.config, this.activeProvider), 'optionalAccess', _439 => _439.model]))), () => ( "unconfigured"));
       const contextUsage = calculateContextUsage(
         messages,
         tools,
         model
       );
       if (contextUsage.isCritical) {
-        _optionalChain([this, 'access', _408 => _408.runtime, 'access', _409 => _409.spinner, 'optionalAccess', _410 => _410.stop, 'call', _411 => _411()]);
+        _optionalChain([this, 'access', _440 => _440.runtime, 'access', _441 => _441.spinner, 'optionalAccess', _442 => _442.stop, 'call', _443 => _443()]);
         console.log(_chalk2.default.yellow("\n\u26A0 Context at critical level, auto-cropping old messages..."));
         const targetTokens = Math.floor(contextUsage.contextWindow * 0.7);
         const tokensToRemove = contextUsage.totalTokens - targetTokens;
@@ -13621,15 +14932,16 @@ ${summary}`
 \u26A0 Context at ${Math.round(contextUsage.usagePercent * 100)}% - approaching limit`));
       }
       if (iteration >= 10 && iteration % 10 === 0) {
-        _optionalChain([this, 'access', _412 => _412.runtime, 'access', _413 => _413.spinner, 'optionalAccess', _414 => _414.start, 'call', _415 => _415(`Working... (step ${iteration + 1})`)]);
+        _optionalChain([this, 'access', _444 => _444.runtime, 'access', _445 => _445.spinner, 'optionalAccess', _446 => _446.start, 'call', _447 => _447(`Working... (step ${iteration + 1})`)]);
       } else {
-        _optionalChain([this, 'access', _416 => _416.runtime, 'access', _417 => _417.spinner, 'optionalAccess', _418 => _418.start, 'call', _419 => _419("Working ...")]);
+        _optionalChain([this, 'access', _448 => _448.runtime, 'access', _449 => _449.spinner, 'optionalAccess', _450 => _450.start, 'call', _451 => _451("Working ...")]);
       }
       const messagesWithImages = this.getMessagesWithImages();
       if (debugMode) process.stderr.write(`[AGENT DEBUG] Calling LLM with ${messagesWithImages.length} messages, ${tools.length} tools
 `);
       let completion;
       try {
+        const thinkingLevel = process.env.AUTOHAND_THINKING_LEVEL || "normal";
         completion = await this.llm.complete({
           messages: messagesWithImages,
           temperature: _nullishCoalesce(this.runtime.options.temperature, () => ( 0.2)),
@@ -13637,10 +14949,11 @@ ${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=${_nullishCoalesce(_optionalChain([completion, 'access', _420 => _420.content, 'optionalAccess', _421 => _421.length]), () => ( 0))}, toolCalls=${_nullishCoalesce(_optionalChain([completion, 'access', _422 => _422.toolCalls, 'optionalAccess', _423 => _423.length]), () => ( 0))}
+        if (debugMode) process.stderr.write(`[AGENT DEBUG] LLM returned: content length=${_nullishCoalesce(_optionalChain([completion, 'access', _452 => _452.content, 'optionalAccess', _453 => _453.length]), () => ( 0))}, toolCalls=${_nullishCoalesce(_optionalChain([completion, 'access', _454 => _454.toolCalls, 'optionalAccess', _455 => _455.length]), () => ( 0))}
 `);
       } catch (llmError) {
         const errMsg = llmError instanceof Error ? llmError.message : String(llmError);
@@ -13656,10 +14969,10 @@ ${summary}`
         this.forceRenderSpinner();
       }
       const payload = this.parseAssistantResponse(completion);
-      if (debugMode) process.stderr.write(`[AGENT DEBUG] Parsed payload: finalResponse=${!!payload.finalResponse}, thought=${!!payload.thought}, toolCalls=${_nullishCoalesce(_optionalChain([payload, 'access', _424 => _424.toolCalls, 'optionalAccess', _425 => _425.length]), () => ( 0))}
+      if (debugMode) process.stderr.write(`[AGENT DEBUG] Parsed payload: finalResponse=${!!payload.finalResponse}, thought=${!!payload.thought}, toolCalls=${_nullishCoalesce(_optionalChain([payload, 'access', _456 => _456.toolCalls, 'optionalAccess', _457 => _457.length]), () => ( 0))}
 `);
       const assistantMessage = { role: "assistant", content: completion.content };
-      if (_optionalChain([completion, 'access', _426 => _426.toolCalls, 'optionalAccess', _427 => _427.length])) {
+      if (_optionalChain([completion, 'access', _458 => _458.toolCalls, 'optionalAccess', _459 => _459.length])) {
         assistantMessage.tool_calls = completion.toolCalls;
       }
       this.conversation.addMessage(assistantMessage);
@@ -13668,14 +14981,14 @@ ${summary}`
       if (debugMode) {
         console.log(_chalk2.default.yellow(`
 [DEBUG] Iteration ${iteration}:`));
-        console.log(_chalk2.default.yellow(`  - toolCalls: ${_nullishCoalesce(_optionalChain([payload, 'access', _428 => _428.toolCalls, 'optionalAccess', _429 => _429.length]), () => ( 0))}`));
-        console.log(_chalk2.default.yellow(`  - thought: ${_optionalChain([payload, 'access', _430 => _430.thought, 'optionalAccess', _431 => _431.slice, 'call', _432 => _432(0, 100)]) || "(none)"}`));
-        console.log(_chalk2.default.yellow(`  - finalResponse: ${_optionalChain([payload, 'access', _433 => _433.finalResponse, 'optionalAccess', _434 => _434.slice, 'call', _435 => _435(0, 100)]) || "(none)"}`));
-        console.log(_chalk2.default.yellow(`  - raw content: ${_optionalChain([completion, 'access', _436 => _436.content, 'optionalAccess', _437 => _437.slice, 'call', _438 => _438(0, 200)]) || "(empty)"}`));
+        console.log(_chalk2.default.yellow(`  - toolCalls: ${_nullishCoalesce(_optionalChain([payload, 'access', _460 => _460.toolCalls, 'optionalAccess', _461 => _461.length]), () => ( 0))}`));
+        console.log(_chalk2.default.yellow(`  - thought: ${_optionalChain([payload, 'access', _462 => _462.thought, 'optionalAccess', _463 => _463.slice, 'call', _464 => _464(0, 100)]) || "(none)"}`));
+        console.log(_chalk2.default.yellow(`  - finalResponse: ${_optionalChain([payload, 'access', _465 => _465.finalResponse, 'optionalAccess', _466 => _466.slice, 'call', _467 => _467(0, 100)]) || "(none)"}`));
+        console.log(_chalk2.default.yellow(`  - raw content: ${_optionalChain([completion, 'access', _468 => _468.content, 'optionalAccess', _469 => _469.slice, 'call', _470 => _470(0, 200)]) || "(empty)"}`));
       }
-      const toolCount = _nullishCoalesce(_optionalChain([payload, 'access', _439 => _439.toolCalls, 'optionalAccess', _440 => _440.length]), () => ( 0));
+      const toolCount = _nullishCoalesce(_optionalChain([payload, 'access', _471 => _471.toolCalls, 'optionalAccess', _472 => _472.length]), () => ( 0));
       const hasResponse = Boolean(payload.finalResponse || payload.response || !toolCount && payload.thought);
-      const thoughtPreview = _optionalChain([payload, 'access', _441 => _441.thought, 'optionalAccess', _442 => _442.slice, 'call', _443 => _443(0, 80)]) || "";
+      const thoughtPreview = _optionalChain([payload, 'access', _473 => _473.thought, 'optionalAccess', _474 => _474.slice, 'call', _475 => _475(0, 80)]) || "";
       if (this.inkRenderer) {
         if (toolCount > 0) {
           const toolNames = payload.toolCalls.map((t) => t.tool).join(", ");
@@ -13722,23 +15035,23 @@ ${summary}`
               role: "tool",
               name: result.tool,
               content,
-              tool_call_id: _optionalChain([otherCalls, 'access', _444 => _444[i], 'optionalAccess', _445 => _445.id])
+              tool_call_id: _optionalChain([otherCalls, 'access', _476 => _476[i], 'optionalAccess', _477 => _477.id])
             });
-            await this.saveToolMessage(result.tool, content, _optionalChain([otherCalls, 'access', _446 => _446[i], 'optionalAccess', _447 => _447.id]));
+            await this.saveToolMessage(result.tool, content, _optionalChain([otherCalls, 'access', _478 => _478[i], 'optionalAccess', _479 => _479.id]));
           }
           this.updateContextUsage(this.conversation.history(), tools);
-          const charLimit = _nullishCoalesce(_optionalChain([this, 'access', _448 => _448.runtime, 'access', _449 => _449.config, 'access', _450 => _450.ui, 'optionalAccess', _451 => _451.readFileCharLimit]), () => ( 300));
+          const charLimit = _nullishCoalesce(_optionalChain([this, 'access', _480 => _480.runtime, 'access', _481 => _481.config, 'access', _482 => _482.ui, 'optionalAccess', _483 => _483.readFileCharLimit]), () => ( 300));
           outputLines.push(this.formatToolResultsBatch(results, charLimit, otherCalls, thought));
         }
         if (this.inkRenderer) {
           const thought2 = showThinking && payload.thought && !payload.thought.trim().startsWith("{") ? payload.thought : void 0;
           if (results.length > 0) {
-            const charLimit = _nullishCoalesce(_optionalChain([this, 'access', _452 => _452.runtime, 'access', _453 => _453.config, 'access', _454 => _454.ui, 'optionalAccess', _455 => _455.readFileCharLimit]), () => ( 300));
+            const charLimit = _nullishCoalesce(_optionalChain([this, 'access', _484 => _484.runtime, 'access', _485 => _485.config, 'access', _486 => _486.ui, 'optionalAccess', _487 => _487.readFileCharLimit]), () => ( 300));
             this.addUIToolOutputs(results.map((r, i) => {
               const call = otherCalls[i];
-              const filePath = _optionalChain([call, 'optionalAccess', _456 => _456.args, 'optionalAccess', _457 => _457.path]);
-              const command = _optionalChain([call, 'optionalAccess', _458 => _458.args, 'optionalAccess', _459 => _459.command]);
-              const commandArgs = _optionalChain([call, 'optionalAccess', _460 => _460.args, 'optionalAccess', _461 => _461.args]);
+              const filePath = _optionalChain([call, 'optionalAccess', _488 => _488.args, 'optionalAccess', _489 => _489.path]);
+              const command = _optionalChain([call, 'optionalAccess', _490 => _490.args, 'optionalAccess', _491 => _491.command]);
+              const commandArgs = _optionalChain([call, 'optionalAccess', _492 => _492.args, 'optionalAccess', _493 => _493.args]);
               return {
                 tool: r.tool,
                 success: r.success,
@@ -13749,13 +15062,13 @@ ${summary}`
             }));
           }
         } else {
-          _optionalChain([this, 'access', _462 => _462.runtime, 'access', _463 => _463.spinner, 'optionalAccess', _464 => _464.stop, 'call', _465 => _465()]);
+          _optionalChain([this, 'access', _494 => _494.runtime, 'access', _495 => _495.spinner, 'optionalAccess', _496 => _496.stop, 'call', _497 => _497()]);
           if (outputLines.length > 0) {
             console.log("\n" + outputLines.join("\n"));
           }
         }
         if (results.length > 0) {
-          const sessionId = _optionalChain([this, 'access', _466 => _466.sessionManager, 'access', _467 => _467.getCurrentSession, 'call', _468 => _468(), 'optionalAccess', _469 => _469.metadata, 'access', _470 => _470.sessionId]) || "unknown";
+          const sessionId = _optionalChain([this, 'access', _498 => _498.sessionManager, 'access', _499 => _499.getCurrentSession, 'call', _500 => _500(), 'optionalAccess', _501 => _501.metadata, 'access', _502 => _502.sessionId]) || "unknown";
           for (const result of results) {
             if (result.success) {
               await this.projectManager.recordSuccess(this.runtime.workspaceRoot, {
@@ -13789,7 +15102,7 @@ ${summary}`
         const searchTools = ["search", "search_with_context", "semantic_search"];
         const searchCallsThisIteration = otherCalls.filter((call) => searchTools.includes(call.tool));
         for (const call of searchCallsThisIteration) {
-          const query = String(_optionalChain([call, 'access', _471 => _471.args, 'optionalAccess', _472 => _472.query]) || _optionalChain([call, 'access', _473 => _473.args, 'optionalAccess', _474 => _474.pattern]) || "unknown");
+          const query = String(_optionalChain([call, 'access', _503 => _503.args, 'optionalAccess', _504 => _504.query]) || _optionalChain([call, 'access', _505 => _505.args, 'optionalAccess', _506 => _506.pattern]) || "unknown");
           this.searchQueries.push(query);
         }
         if (searchCallsThisIteration.length >= 3) {
@@ -13810,7 +15123,7 @@ ${summary}`
         continue;
       }
       const pendingResponse = payload.finalResponse || payload.response || "";
-      if (this.expressesIntentToAct(pendingResponse) && !_optionalChain([payload, 'access', _475 => _475.toolCalls, 'optionalAccess', _476 => _476.length])) {
+      if (this.expressesIntentToAct(pendingResponse) && !_optionalChain([payload, 'access', _507 => _507.toolCalls, 'optionalAccess', _508 => _508.length])) {
         const intentRetryKey = "__intentRetryCount";
         const intentRetries = (_nullishCoalesce(this[intentRetryKey], () => ( 0))) + 1;
         this[intentRetryKey] = intentRetries;
@@ -13826,17 +15139,21 @@ ${summary}`
       }
       this.stopStatusUpdates();
       let rawResponse;
+      const usedThoughtAsResponse = Boolean(payload.thought) && !payload.finalResponse && !payload.response && !_optionalChain([payload, 'access', _509 => _509.toolCalls, 'optionalAccess', _510 => _510.length]);
       if (payload.finalResponse) {
         rawResponse = payload.finalResponse;
       } else if (payload.response) {
         rawResponse = payload.response;
-      } else if (!_optionalChain([payload, 'access', _477 => _477.toolCalls, 'optionalAccess', _478 => _478.length]) && payload.thought) {
+      } else if (!_optionalChain([payload, 'access', _511 => _511.toolCalls, 'optionalAccess', _512 => _512.length]) && payload.thought) {
         rawResponse = payload.thought;
       } else {
         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 = (_nullishCoalesce(this[consecutiveEmptyKey], () => ( 0))) + 1;
@@ -13850,7 +15167,7 @@ ${summary}`
             this.inkRenderer.setWorking(false);
             this.inkRenderer.setFinalResponse(fallback);
           } else {
-            _optionalChain([this, 'access', _479 => _479.runtime, 'access', _480 => _480.spinner, 'optionalAccess', _481 => _481.stop, 'call', _482 => _482()]);
+            _optionalChain([this, 'access', _513 => _513.runtime, 'access', _514 => _514.spinner, 'optionalAccess', _515 => _515.stop, 'call', _516 => _516()]);
             console.log(fallback);
           }
           this[consecutiveEmptyKey] = 0;
@@ -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));
@@ -13876,8 +15194,8 @@ ${summary}`
         this.inkRenderer.setWorking(false);
         this.inkRenderer.setFinalResponse(response);
       } else {
-        _optionalChain([this, 'access', _483 => _483.runtime, 'access', _484 => _484.spinner, 'optionalAccess', _485 => _485.stop, 'call', _486 => _486()]);
-        if (showThinking && payload.thought && !payload.thought.trim().startsWith("{")) {
+        _optionalChain([this, 'access', _517 => _517.runtime, 'access', _518 => _518.spinner, 'optionalAccess', _519 => _519.stop, 'call', _520 => _520()]);
+        if (showThinking && payload.thought && !suppressThinking && !payload.thought.trim().startsWith("{")) {
           console.log(_chalk2.default.gray(`Thinking: ${payload.thought}`));
           console.log();
         }
@@ -13886,7 +15204,7 @@ ${summary}`
       return;
     }
     this.stopStatusUpdates();
-    _optionalChain([this, 'access', _487 => _487.runtime, 'access', _488 => _488.spinner, 'optionalAccess', _489 => _489.stop, 'call', _490 => _490()]);
+    _optionalChain([this, 'access', _521 => _521.runtime, 'access', _522 => _522.spinner, 'optionalAccess', _523 => _523.stop, 'call', _524 => _524()]);
     console.log(_chalk2.default.yellow(`
 \u26A0 Task exceeded ${maxIterations} tool iterations without completing.`));
     console.log(_chalk2.default.gray("This usually means the task is too complex for a single turn."));
@@ -13899,7 +15217,7 @@ ${summary}`
    * while falling back to JSON parsing for providers without native support.
    */
   parseAssistantResponse(completion) {
-    if (_optionalChain([completion, 'access', _491 => _491.toolCalls, 'optionalAccess', _492 => _492.length])) {
+    if (_optionalChain([completion, 'access', _525 => _525.toolCalls, 'optionalAccess', _526 => _526.length])) {
       let thought;
       if (completion.content) {
         const trimmed = completion.content.trim();
@@ -13907,7 +15225,7 @@ ${summary}`
           try {
             const parsed = JSON.parse(trimmed);
             thought = typeof parsed.thought === "string" ? parsed.thought : void 0;
-          } catch (e72) {
+          } catch (e81) {
             thought = this.cleanupModelResponse(trimmed) || void 0;
           }
         } else {
@@ -13974,9 +15292,9 @@ ${summary}`
         return { finalResponse: contentValue };
       }
       return { finalResponse: raw.trim() };
-    } catch (e73) {
+    } catch (e82) {
       const thoughtMatch = raw.match(/"thought"\s*:\s*"([^"]+)"/);
-      if (_optionalChain([thoughtMatch, 'optionalAccess', _493 => _493[1]])) {
+      if (_optionalChain([thoughtMatch, 'optionalAccess', _527 => _527[1]])) {
         return { thought: thoughtMatch[1], finalResponse: thoughtMatch[1] };
       }
       if (raw.trim().startsWith("{")) {
@@ -14116,11 +15434,11 @@ ${mentionContext.block}`);
     return `- ${def.name}(${args}) - ${def.description}`;
   }
   async buildSystemPrompt() {
-    const toolDefs = _nullishCoalesce(_optionalChain([this, 'access', _494 => _494.toolManager, 'optionalAccess', _495 => _495.listDefinitions, 'call', _496 => _496()]), () => ( []));
+    const toolDefs = _nullishCoalesce(_optionalChain([this, 'access', _528 => _528.toolManager, 'optionalAccess', _529 => _529.listDefinitions, 'call', _530 => _530()]), () => ( []));
     const toolSignatures = toolDefs.map((def) => this.formatToolSignature(def)).join("\n");
     const memories = await this.memoryManager.getContextMemories();
     const instructions = await this.loadInstructionFiles();
-    const authUser = _optionalChain([this, 'access', _497 => _497.runtime, 'access', _498 => _498.config, 'access', _499 => _499.auth, 'optionalAccess', _500 => _500.user]);
+    const authUser = _optionalChain([this, 'access', _531 => _531.runtime, 'access', _532 => _532.config, 'access', _533 => _533.auth, 'optionalAccess', _534 => _534.user]);
     const parts = [
       // ═══════════════════════════════════════════════════════════════════
       // 1. IDENTITY & CORE STANDARDS
@@ -14456,7 +15774,7 @@ ${toolSignatures}
     try {
       const stats = await _fsextra2.default.stat(fullPath);
       return stats.isFile();
-    } catch (e74) {
+    } catch (e83) {
       return false;
     }
   }
@@ -14617,10 +15935,10 @@ ${ctx.contents}`).join("\n\n");
     for (let i = 0; i < results.length; i++) {
       const result = results[i];
       const content = result.success ? _nullishCoalesce(result.output, () => ( "(no output)")) : _nullishCoalesce(_nullishCoalesce(result.error, () => ( result.output)), () => ( "Tool failed without error message"));
-      const call = _optionalChain([toolCalls, 'optionalAccess', _501 => _501[i]]);
-      const filePath = _optionalChain([call, 'optionalAccess', _502 => _502.args, 'optionalAccess', _503 => _503.path]);
-      const command = _optionalChain([call, 'optionalAccess', _504 => _504.args, 'optionalAccess', _505 => _505.command]);
-      const commandArgs = _optionalChain([call, 'optionalAccess', _506 => _506.args, 'optionalAccess', _507 => _507.args]);
+      const call = _optionalChain([toolCalls, 'optionalAccess', _535 => _535[i]]);
+      const filePath = _optionalChain([call, 'optionalAccess', _536 => _536.args, 'optionalAccess', _537 => _537.path]);
+      const command = _optionalChain([call, 'optionalAccess', _538 => _538.args, 'optionalAccess', _539 => _539.command]);
+      const commandArgs = _optionalChain([call, 'optionalAccess', _540 => _540.args, 'optionalAccess', _541 => _541.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 ? _chalk2.default.green("\u2714") : _chalk2.default.red("\u2716");
       lines.push(`${icon} ${_chalk2.default.bold(result.tool)}`);
@@ -14651,22 +15969,22 @@ ${ctx.contents}`).join("\n\n");
         )));
         this.inkRenderer = createInkRenderer({
           onInstruction: (text) => {
-            _optionalChain([this, 'access', _508 => _508.inkRenderer, 'optionalAccess', _509 => _509.addQueuedInstruction, 'call', _510 => _510(text)]);
+            _optionalChain([this, 'access', _542 => _542.inkRenderer, 'optionalAccess', _543 => _543.addQueuedInstruction, 'call', _544 => _544(text)]);
           },
           onEscape: () => {
             if (abortController && !abortController.signal.aborted) {
               abortController.abort();
-              _optionalChain([onCancel, 'optionalCall', _511 => _511()]);
+              _optionalChain([onCancel, 'optionalCall', _545 => _545()]);
             }
           },
           onCtrlC: () => {
           },
-          enableQueueInput: _optionalChain([this, 'access', _512 => _512.runtime, 'access', _513 => _513.config, 'access', _514 => _514.agent, 'optionalAccess', _515 => _515.enableRequestQueue]) !== false
+          enableQueueInput: _optionalChain([this, 'access', _546 => _546.runtime, 'access', _547 => _547.config, 'access', _548 => _548.agent, 'optionalAccess', _549 => _549.enableRequestQueue]) !== false
         });
         this.inkRenderer.start();
         this.inkRenderer.setWorking(true, "Gathering context...");
         this.runtime.inkRenderer = this.inkRenderer;
-      } catch (e75) {
+      } catch (e84) {
         this.useInkRenderer = false;
         this.initFallbackSpinner();
       }
@@ -14819,7 +16137,7 @@ ${parts.join("\n")}`
       return () => {
       };
     }
-    _readline2.default.emitKeypressEvents(input);
+    safeEmitKeypressEvents(input);
     const supportsRaw = typeof input.setRawMode === "function";
     const wasRaw = input.isRaw;
     if (!wasRaw && supportsRaw) {
@@ -14827,17 +16145,17 @@ ${parts.join("\n")}`
     }
     let ctrlCCount = 0;
     this.queueInput = "";
-    const enableQueue = _optionalChain([this, 'access', _516 => _516.runtime, 'access', _517 => _517.config, 'access', _518 => _518.agent, 'optionalAccess', _519 => _519.enableRequestQueue]) !== false;
+    const enableQueue = _optionalChain([this, 'access', _550 => _550.runtime, 'access', _551 => _551.config, 'access', _552 => _552.agent, 'optionalAccess', _553 => _553.enableRequestQueue]) !== false;
     const handler = (_str, key) => {
       if (controller.signal.aborted) {
         return;
       }
-      if (_optionalChain([key, 'optionalAccess', _520 => _520.name]) === "escape") {
+      if (_optionalChain([key, 'optionalAccess', _554 => _554.name]) === "escape") {
         controller.abort();
         onCancel();
         return;
       }
-      if (ctrlCInterrupt && _optionalChain([key, 'optionalAccess', _521 => _521.name]) === "c" && key.ctrl) {
+      if (ctrlCInterrupt && _optionalChain([key, 'optionalAccess', _555 => _555.name]) === "c" && key.ctrl) {
         ctrlCCount += 1;
         if (ctrlCCount >= 2) {
           controller.abort();
@@ -14848,7 +16166,7 @@ ${parts.join("\n")}`
         return;
       }
       if (enableQueue) {
-        if (_optionalChain([key, 'optionalAccess', _522 => _522.name]) === "return" || _optionalChain([key, 'optionalAccess', _523 => _523.name]) === "enter") {
+        if (_optionalChain([key, 'optionalAccess', _556 => _556.name]) === "return" || _optionalChain([key, 'optionalAccess', _557 => _557.name]) === "enter") {
           if (this.queueInput.trim()) {
             const text = this.queueInput.trim();
             this.queueInput = "";
@@ -14864,12 +16182,12 @@ ${parts.join("\n")}`
           }
           return;
         }
-        if (_optionalChain([key, 'optionalAccess', _524 => _524.name]) === "backspace") {
+        if (_optionalChain([key, 'optionalAccess', _558 => _558.name]) === "backspace") {
           this.queueInput = this.queueInput.slice(0, -1);
           this.updateInputLine();
           return;
         }
-        if (_optionalChain([key, 'optionalAccess', _525 => _525.ctrl]) || _optionalChain([key, 'optionalAccess', _526 => _526.meta])) {
+        if (_optionalChain([key, 'optionalAccess', _559 => _559.ctrl]) || _optionalChain([key, 'optionalAccess', _560 => _560.meta])) {
           return;
         }
         if (_str) {
@@ -15000,8 +16318,8 @@ ${parts.join("\n")}`
   async submitSessionFailureBugReport(error, retryAttempt, maxRetries) {
     try {
       const history = this.conversation.history();
-      const recentToolCalls = history.filter((m) => m.role === "assistant" && m.tool_calls).slice(-3).flatMap((m) => _optionalChain([m, 'access', _527 => _527.tool_calls, 'optionalAccess', _528 => _528.map, 'call', _529 => _529((tc) => _optionalChain([tc, 'access', _530 => _530.function, 'optionalAccess', _531 => _531.name]))]) || []).filter(Boolean);
-      const model = _nullishCoalesce(this.runtime.options.model, () => ( _optionalChain([_chunkQMVTT55Ycjs.getProviderConfig.call(void 0, this.runtime.config, this.activeProvider), 'optionalAccess', _532 => _532.model])));
+      const recentToolCalls = history.filter((m) => m.role === "assistant" && m.tool_calls).slice(-3).flatMap((m) => _optionalChain([m, 'access', _561 => _561.tool_calls, 'optionalAccess', _562 => _562.map, 'call', _563 => _563((tc) => _optionalChain([tc, 'access', _564 => _564.function, 'optionalAccess', _565 => _565.name]))]) || []).filter(Boolean);
+      const model = _nullishCoalesce(this.runtime.options.model, () => ( _optionalChain([_chunkQMVTT55Ycjs.getProviderConfig.call(void 0, this.runtime.config, this.activeProvider), 'optionalAccess', _566 => _566.model])));
       await this.telemetryManager.trackSessionFailureBug({
         error,
         retryAttempt,
@@ -15224,7 +16542,7 @@ ${parts.join("\n")}`
     const elapsed = this.formatElapsedTime(this.taskStartedAt);
     const sessionTotal = this.sessionTokensUsed + this.totalTokensUsed;
     const tokens = this.formatTokens(sessionTotal);
-    const queueCount = _nullishCoalesce(_optionalChain([this, 'access', _533 => _533.inkRenderer, 'optionalAccess', _534 => _534.getQueueCount, 'call', _535 => _535()]), () => ( this.persistentInput.getQueueLength()));
+    const queueCount = _nullishCoalesce(_optionalChain([this, 'access', _567 => _567.inkRenderer, 'optionalAccess', _568 => _568.getQueueCount, 'call', _569 => _569()]), () => ( this.persistentInput.getQueueLength()));
     const queueHint = queueCount > 0 ? ` [${queueCount} queued]` : "";
     const statusLine = `Working... (esc to interrupt \xB7 ${elapsed} \xB7 ${tokens}${queueHint})`;
     if (this.inkRenderer) {
@@ -15264,7 +16582,7 @@ ${_chalk2.default.gray("\u203A")} ${inputPreview}${_chalk2.default.gray("\u258B"
       return;
     }
     if (tools) {
-      const model = _nullishCoalesce(_nullishCoalesce(this.runtime.options.model, () => ( _optionalChain([_chunkQMVTT55Ycjs.getProviderConfig.call(void 0, this.runtime.config, this.activeProvider), 'optionalAccess', _536 => _536.model]))), () => ( "unconfigured"));
+      const model = _nullishCoalesce(_nullishCoalesce(this.runtime.options.model, () => ( _optionalChain([_chunkQMVTT55Ycjs.getProviderConfig.call(void 0, this.runtime.config, this.activeProvider), 'optionalAccess', _570 => _570.model]))), () => ( "unconfigured"));
       const usage = calculateContextUsage(
         messages,
         tools,
@@ -15278,9 +16596,28 @@ ${_chalk2.default.gray("\u203A")} ${inputPreview}${_chalk2.default.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 (e85) {
+    }
+  }
   formatStatusLine() {
     const percent = Number.isFinite(this.contextPercentLeft) ? Math.max(0, Math.min(100, this.contextPercentLeft)) : 100;
-    const queueCount = _nullishCoalesce(_optionalChain([this, 'access', _537 => _537.inkRenderer, 'optionalAccess', _538 => _538.getQueueCount, 'call', _539 => _539()]), () => ( this.persistentInput.getQueueLength()));
+    const queueCount = _nullishCoalesce(_optionalChain([this, 'access', _571 => _571.inkRenderer, 'optionalAccess', _572 => _572.getQueueCount, 'call', _573 => _573()]), () => ( this.persistentInput.getQueueLength()));
     const queueStatus = queueCount > 0 ? ` \xB7 ${queueCount} queued` : "";
     return `${percent}% context left \xB7 / for commands \xB7 @ to mention files${queueStatus}`;
   }
@@ -15336,7 +16673,7 @@ ${_chalk2.default.gray("\u203A")} ${inputPreview}${_chalk2.default.gray("\u258B"
     this.activeProvider = provider;
   }
   async confirmDangerousAction(message, context) {
-    if (this.runtime.options.yes || _optionalChain([this, 'access', _540 => _540.runtime, 'access', _541 => _541.config, 'access', _542 => _542.ui, 'optionalAccess', _543 => _543.autoConfirm])) {
+    if (this.runtime.options.yes || _optionalChain([this, 'access', _574 => _574.runtime, 'access', _575 => _575.config, 'access', _576 => _576.ui, 'optionalAccess', _577 => _577.autoConfirm])) {
       return true;
     }
     if (this.confirmationCallback) {
@@ -15346,9 +16683,9 @@ ${_chalk2.default.gray("\u203A")} ${inputPreview}${_chalk2.default.gray("\u258B"
       return confirm(message);
     }
     this.stopStatusUpdates();
-    const spinnerWasSpinning = _optionalChain([this, 'access', _544 => _544.runtime, 'access', _545 => _545.spinner, 'optionalAccess', _546 => _546.isSpinning]);
+    const spinnerWasSpinning = _optionalChain([this, 'access', _578 => _578.runtime, 'access', _579 => _579.spinner, 'optionalAccess', _580 => _580.isSpinning]);
     if (spinnerWasSpinning) {
-      _optionalChain([this, 'access', _547 => _547.runtime, 'access', _548 => _548.spinner, 'optionalAccess', _549 => _549.stop, 'call', _550 => _550()]);
+      _optionalChain([this, 'access', _581 => _581.runtime, 'access', _582 => _582.spinner, 'optionalAccess', _583 => _583.stop, 'call', _584 => _584()]);
     }
     this.persistentInput.pause();
     if (this.inkRenderer) {
@@ -15409,7 +16746,7 @@ ${_chalk2.default.gray("\u203A")} ${inputPreview}${_chalk2.default.gray("\u258B"
   getStatusSnapshot() {
     const providerSettings = _chunkQMVTT55Ycjs.getProviderConfig.call(void 0, this.runtime.config, this.activeProvider);
     return {
-      model: _nullishCoalesce(_nullishCoalesce(this.runtime.options.model, () => ( _optionalChain([providerSettings, 'optionalAccess', _551 => _551.model]))), () => ( "unconfigured")),
+      model: _nullishCoalesce(_nullishCoalesce(this.runtime.options.model, () => ( _optionalChain([providerSettings, 'optionalAccess', _585 => _585.model]))), () => ( "unconfigured")),
       workspace: this.runtime.workspaceRoot,
       contextPercent: this.contextPercentLeft,
       tokensUsed: this.totalTokensUsed
@@ -15498,7 +16835,7 @@ var PYTHON_FRAMEWORKS = {
   tensorflow: ["tensorflow"],
   pytorch: ["torch"]
 };
-var ProjectAnalyzer = class {
+var ProjectAnalyzer2 = class {
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
   }
@@ -15595,7 +16932,7 @@ var ProjectAnalyzer = class {
       if (allDeps.eslint || allDeps.prettier || allDeps.biome) {
         analysis.patterns.push("linting");
       }
-    } catch (e76) {
+    } catch (e86) {
     }
   }
   /**
@@ -15620,7 +16957,7 @@ var ProjectAnalyzer = class {
           analysis.hasTests = true;
           analysis.patterns.push("testing");
         }
-      } catch (e77) {
+      } catch (e87) {
       }
     }
     if (await _fsextra2.default.pathExists(pyprojectPath)) {
@@ -15689,7 +17026,7 @@ var ProjectAnalyzer = class {
             }
           }
         }
-      } catch (e78) {
+      } catch (e88) {
       }
     }
     await walk(this.projectRoot, 0);
@@ -15805,21 +17142,21 @@ async function generateAutoSkills(analysis, llm) {
     let skills = [];
     try {
       skills = JSON.parse(content);
-    } catch (e79) {
+    } catch (e89) {
       const jsonMatch = content.match(/\[[\s\S]*\]/);
       if (!jsonMatch) {
         return [];
       }
       try {
         skills = JSON.parse(jsonMatch[0]);
-      } catch (e80) {
+      } catch (e90) {
         return [];
       }
     }
     return skills.filter(
       (s) => s && typeof s.name === "string" && typeof s.description === "string" && typeof s.body === "string" && /^[a-z0-9-]+$/.test(s.name)
     );
-  } catch (e81) {
+  } catch (e91) {
     return [];
   }
 }
@@ -15842,7 +17179,7 @@ allowed-tools: ${skill.allowedTools.join(" ")}`;
     const content = frontmatter + skill.body + "\n";
     await _fsextra2.default.writeFile(skillPath, content, "utf-8");
     return true;
-  } catch (e82) {
+  } catch (e92) {
     return false;
   }
 }
@@ -15853,11 +17190,11 @@ async function runAutoSkillGeneration(workspaceRoot, llm) {
     skills: []
   };
   console.log(_chalk2.default.cyan("Analyzing project structure..."));
-  const analyzer = new ProjectAnalyzer(workspaceRoot);
+  const analyzer = new ProjectAnalyzer2(workspaceRoot);
   let analysis;
   try {
     analysis = await analyzer.analyze();
-  } catch (e83) {
+  } catch (e93) {
     result.error = "Failed to analyze project";
     return result;
   }
@@ -16021,7 +17358,7 @@ function parseRequest(line) {
   let parsed;
   try {
     parsed = JSON.parse(trimmed);
-  } catch (e84) {
+  } catch (e94) {
     return {
       type: "error",
       code: JSON_RPC_ERROR_CODES.PARSE_ERROR,
@@ -16228,7 +17565,7 @@ var RPCAdapter = class {
     this.model = model;
     this.workspace = workspace;
     this.sessionId = generateId("session");
-    this.imageManager = _nullishCoalesce(_optionalChain([agent, 'access', _552 => _552.getImageManager, 'optionalCall', _553 => _553()]), () => ( new ImageManager()));
+    this.imageManager = _nullishCoalesce(_optionalChain([agent, 'access', _586 => _586.getImageManager, 'optionalCall', _587 => _587()]), () => ( new ImageManager()));
     agent.setStatusListener((snapshot) => {
       this.contextPercent = snapshot.contextPercent;
       this.model = snapshot.model;
@@ -16254,7 +17591,7 @@ var RPCAdapter = class {
       model: this.model,
       workspace: this.workspace,
       contextPercent: this.contextPercent,
-      messageCount: _nullishCoalesce(_optionalChain([this, 'access', _554 => _554.conversation, 'optionalAccess', _555 => _555.history, 'call', _556 => _556(), 'access', _557 => _557.length]), () => ( 0))
+      messageCount: _nullishCoalesce(_optionalChain([this, 'access', _588 => _588.conversation, 'optionalAccess', _589 => _589.history, 'call', _590 => _590(), 'access', _591 => _591.length]), () => ( 0))
     };
   }
   /**
@@ -16291,7 +17628,7 @@ var RPCAdapter = class {
     });
     try {
       const imagePlaceholders = [];
-      process.stderr.write(`[RPC] handlePrompt: images=${_optionalChain([params, 'access', _558 => _558.images, 'optionalAccess', _559 => _559.length]) || 0}, hasImageManager=${!!this.imageManager}, model=${this.model}
+      process.stderr.write(`[RPC] handlePrompt: images=${_optionalChain([params, 'access', _592 => _592.images, 'optionalAccess', _593 => _593.length]) || 0}, hasImageManager=${!!this.imageManager}, model=${this.model}
 `);
       if (params.images && params.images.length > 0) {
         if (!supportsVision(this.model)) {
@@ -16310,7 +17647,7 @@ var RPCAdapter = class {
 `);
         for (const img of params.images) {
           try {
-            process.stderr.write(`[RPC] Image: mimeType=${img.mimeType}, dataLength=${_optionalChain([img, 'access', _560 => _560.data, 'optionalAccess', _561 => _561.length]) || 0}
+            process.stderr.write(`[RPC] Image: mimeType=${img.mimeType}, dataLength=${_optionalChain([img, 'access', _594 => _594.data, 'optionalAccess', _595 => _595.length]) || 0}
 `);
             if (!isValidImageMimeType(img.mimeType)) {
               process.stderr.write(`[RPC] Invalid MIME type: ${img.mimeType}
@@ -16363,7 +17700,7 @@ ${instruction}`;
           process.stderr.write(`[RPC] WARNING: Images provided but no placeholders generated!
 `);
         }
-        if (_optionalChain([params, 'access', _562 => _562.context, 'optionalAccess', _563 => _563.selection])) {
+        if (_optionalChain([params, 'access', _596 => _596.context, 'optionalAccess', _597 => _597.selection])) {
           const sel = params.context.selection;
           instruction = `${instruction}
 
@@ -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 = _optionalChain([this, 'access', _598 => _598.agent, 'optionalAccess', _599 => _599.getHookManager, 'optionalCall', _600 => _600()]);
+        if (hookManager) {
+          const snapshot2 = _optionalChain([this, 'access', _601 => _601.agent, 'optionalAccess', _602 => _602.getStatusSnapshot, 'call', _603 => _603()]);
+          await hookManager.executeHooks("stop", {
+            sessionId: this.sessionId || void 0,
+            turnDuration,
+            tokensUsed: _nullishCoalesce(_optionalChain([snapshot2, 'optionalAccess', _604 => _604.tokensUsed]), () => ( 0))
+          });
+          this.emitHookStop(
+            _nullishCoalesce(_optionalChain([snapshot2, 'optionalAccess', _605 => _605.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 : "";
@@ -16475,12 +17828,12 @@ ${sel.text}
         timestamp: createTimestamp()
       });
       const durationMs = this.turnStartTime ? Date.now() - this.turnStartTime : void 0;
-      const snapshot = _optionalChain([this, 'access', _564 => _564.agent, 'optionalAccess', _565 => _565.getStatusSnapshot, 'call', _566 => _566()]);
+      const snapshot = _optionalChain([this, 'access', _606 => _606.agent, 'optionalAccess', _607 => _607.getStatusSnapshot, 'call', _608 => _608()]);
       writeNotification(RPC_NOTIFICATIONS.TURN_END, {
         turnId: this.currentTurnId,
         timestamp: createTimestamp(),
         contextPercent: this.contextPercent,
-        tokensUsed: _optionalChain([snapshot, 'optionalAccess', _567 => _567.tokensUsed]),
+        tokensUsed: _optionalChain([snapshot, 'optionalAccess', _609 => _609.tokensUsed]),
         durationMs
       });
       this.status = "idle";
@@ -16491,12 +17844,12 @@ ${sel.text}
       return { success };
     } catch (error) {
       const durationMs = this.turnStartTime ? Date.now() - this.turnStartTime : void 0;
-      const snapshot = _optionalChain([this, 'access', _568 => _568.agent, 'optionalAccess', _569 => _569.getStatusSnapshot, 'call', _570 => _570()]);
+      const snapshot = _optionalChain([this, 'access', _610 => _610.agent, 'optionalAccess', _611 => _611.getStatusSnapshot, 'call', _612 => _612()]);
       writeNotification(RPC_NOTIFICATIONS.TURN_END, {
         turnId: this.currentTurnId,
         timestamp: createTimestamp(),
         contextPercent: this.contextPercent,
-        tokensUsed: _optionalChain([snapshot, 'optionalAccess', _571 => _571.tokensUsed]),
+        tokensUsed: _optionalChain([snapshot, 'optionalAccess', _613 => _613.tokensUsed]),
         durationMs
       });
       this.status = "idle";
@@ -16535,12 +17888,12 @@ ${sel.text}
       }
       if (this.currentTurnId) {
         const durationMs = this.turnStartTime ? Date.now() - this.turnStartTime : void 0;
-        const snapshot = _optionalChain([this, 'access', _572 => _572.agent, 'optionalAccess', _573 => _573.getStatusSnapshot, 'call', _574 => _574()]);
+        const snapshot = _optionalChain([this, 'access', _614 => _614.agent, 'optionalAccess', _615 => _615.getStatusSnapshot, 'call', _616 => _616()]);
         writeNotification(RPC_NOTIFICATIONS.TURN_END, {
           turnId: this.currentTurnId,
           timestamp: createTimestamp(),
           contextPercent: this.contextPercent,
-          tokensUsed: _optionalChain([snapshot, 'optionalAccess', _575 => _575.tokensUsed]),
+          tokensUsed: _optionalChain([snapshot, 'optionalAccess', _617 => _617.tokensUsed]),
           durationMs
         });
       }
@@ -16559,10 +17912,10 @@ ${sel.text}
   handleReset(requestId) {
     if (this.conversation) {
       const history = this.conversation.history();
-      const systemPrompt = _nullishCoalesce(_optionalChain([history, 'access', _576 => _576.find, 'call', _577 => _577((m) => m.role === "system"), 'optionalAccess', _578 => _578.content]), () => ( ""));
+      const systemPrompt = _nullishCoalesce(_optionalChain([history, 'access', _618 => _618.find, 'call', _619 => _619((m) => m.role === "system"), 'optionalAccess', _620 => _620.content]), () => ( ""));
       this.conversation.reset(systemPrompt);
     }
-    _optionalChain([this, 'access', _579 => _579.imageManager, 'optionalAccess', _580 => _580.clear, 'call', _581 => _581()]);
+    _optionalChain([this, 'access', _621 => _621.imageManager, 'optionalAccess', _622 => _622.clear, 'call', _623 => _623()]);
     this.sessionId = generateId("session");
     this.status = "idle";
     this.currentTurnId = null;
@@ -16922,7 +18275,7 @@ ${sel.text}
    * Handle changes decision from client (accept/reject)
    */
   async handleChangesDecision(requestId, params) {
-    const fileManager = _optionalChain([this, 'access', _582 => _582.agent, 'optionalAccess', _583 => _583.getFileManager, 'optionalCall', _584 => _584()]);
+    const fileManager = _optionalChain([this, 'access', _624 => _624.agent, 'optionalAccess', _625 => _625.getFileManager, 'optionalCall', _626 => _626()]);
     if (!fileManager) {
       return {
         success: false,
@@ -16974,7 +18327,7 @@ ${sel.text}
       const cache = new CommunitySkillsCache();
       const fetcher = new GitHubRegistryFetcher();
       let registry;
-      if (_optionalChain([params, 'optionalAccess', _585 => _585.forceRefresh])) {
+      if (_optionalChain([params, 'optionalAccess', _627 => _627.forceRefresh])) {
         process.stderr.write("[RPC] Force refreshing skills registry from GitHub\n");
         registry = await fetcher.fetchRegistry();
         await cache.setRegistry(registry);
@@ -17021,7 +18374,7 @@ ${sel.text}
    */
   async handleInstallSkill(requestId, params) {
     try {
-      const skillsRegistry = _optionalChain([this, 'access', _586 => _586.agent, 'optionalAccess', _587 => _587.getSkillsRegistry, 'optionalCall', _588 => _588()]);
+      const skillsRegistry = _optionalChain([this, 'access', _628 => _628.agent, 'optionalAccess', _629 => _629.getSkillsRegistry, 'optionalCall', _630 => _630()]);
       if (!skillsRegistry) {
         return {
           success: false,
@@ -17125,7 +18478,7 @@ ${sel.text}
    * Handle output events from the agent
    */
   handleAgentOutput(event) {
-    process.stderr.write(`[RPC DEBUG] handleAgentOutput: type=${event.type}, content length=${_nullishCoalesce(_optionalChain([event, 'access', _589 => _589.content, 'optionalAccess', _590 => _590.length]), () => ( 0))}
+    process.stderr.write(`[RPC DEBUG] handleAgentOutput: type=${event.type}, content length=${_nullishCoalesce(_optionalChain([event, 'access', _631 => _631.content, 'optionalAccess', _632 => _632.length]), () => ( 0))}
 `);
     switch (event.type) {
       case "thinking":
@@ -17233,14 +18586,14 @@ ${sel.text}
       toolCalls = msg.tool_calls.map((tc) => {
         let args = {};
         try {
-          if (_optionalChain([tc, 'access', _591 => _591.function, 'optionalAccess', _592 => _592.arguments])) {
+          if (_optionalChain([tc, 'access', _633 => _633.function, 'optionalAccess', _634 => _634.arguments])) {
             args = JSON.parse(tc.function.arguments);
           }
-        } catch (e85) {
+        } catch (e95) {
         }
         return {
           id: tc.id,
-          name: _nullishCoalesce(_optionalChain([tc, 'access', _593 => _593.function, 'optionalAccess', _594 => _594.name]), () => ( "unknown")),
+          name: _nullishCoalesce(_optionalChain([tc, 'access', _635 => _635.function, 'optionalAccess', _636 => _636.name]), () => ( "unknown")),
           args
         };
       });
@@ -17299,18 +18652,18 @@ async function runRpcMode(options) {
     adapter.initialize(
       agent,
       conversation,
-      _nullishCoalesce(_nullishCoalesce(options.model, () => ( _optionalChain([config, 'access', _595 => _595.openrouter, 'optionalAccess', _596 => _596.model]))), () => ( "unknown")),
+      _nullishCoalesce(_nullishCoalesce(options.model, () => ( _optionalChain([config, 'access', _637 => _637.openrouter, 'optionalAccess', _638 => _638.model]))), () => ( "unknown")),
       workspaceRoot
     );
     agent.setConfirmationCallback(async (message, context) => {
       if (!adapter) {
         throw new Error("RPC adapter not initialized");
       }
-      const tool = _nullishCoalesce(_optionalChain([context, 'optionalAccess', _597 => _597.tool]), () => ( "action"));
+      const tool = _nullishCoalesce(_optionalChain([context, 'optionalAccess', _639 => _639.tool]), () => ( "action"));
       const description = message;
       const permContext = {};
-      if (_optionalChain([context, 'optionalAccess', _598 => _598.command])) permContext.command = context.command;
-      if (_optionalChain([context, 'optionalAccess', _599 => _599.path])) permContext.path = context.path;
+      if (_optionalChain([context, 'optionalAccess', _640 => _640.command])) permContext.command = context.command;
+      if (_optionalChain([context, 'optionalAccess', _641 => _641.path])) permContext.path = context.path;
       return adapter.requestPermission(tool, description, permContext);
     });
     const reader = new LineReader(process.stdin);
@@ -17329,7 +18682,7 @@ async function runRpcMode(options) {
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     writeErrorResponse(null, JSON_RPC_ERROR_CODES.INTERNAL_ERROR, `Initialization error: ${message}`);
-    _optionalChain([adapter, 'optionalAccess', _600 => _600.shutdown, 'call', _601 => _601("error")]);
+    _optionalChain([adapter, 'optionalAccess', _642 => _642.shutdown, 'call', _643 => _643("error")]);
     process.exit(1);
   }
 }
@@ -17362,7 +18715,7 @@ async function handleSingleRequest(request, adapter) {
     switch (method) {
       case RPC_METHODS.PROMPT: {
         const promptParams = params;
-        if (!_optionalChain([promptParams, 'optionalAccess', _602 => _602.message])) {
+        if (!_optionalChain([promptParams, 'optionalAccess', _644 => _644.message])) {
           if (shouldRespond) {
             return createErrorResponse(
               id,
@@ -17404,12 +18757,12 @@ async function handleSingleRequest(request, adapter) {
       }
       case RPC_METHODS.GET_MESSAGES: {
         const messagesParams = params;
-        result = adapter.handleGetMessages(id, _optionalChain([messagesParams, 'optionalAccess', _603 => _603.limit]));
+        result = adapter.handleGetMessages(id, _optionalChain([messagesParams, 'optionalAccess', _645 => _645.limit]));
         break;
       }
       case RPC_METHODS.PERMISSION_RESPONSE: {
         const permParams = params;
-        if (!_optionalChain([permParams, 'optionalAccess', _604 => _604.requestId]) || _optionalChain([permParams, 'optionalAccess', _605 => _605.allowed]) === void 0) {
+        if (!_optionalChain([permParams, 'optionalAccess', _646 => _646.requestId]) || _optionalChain([permParams, 'optionalAccess', _647 => _647.allowed]) === void 0) {
           if (shouldRespond) {
             return createErrorResponse(
               id,
@@ -17424,7 +18777,7 @@ async function handleSingleRequest(request, adapter) {
       }
       case RPC_METHODS.PERMISSION_ACKNOWLEDGED: {
         const ackParams = params;
-        if (!_optionalChain([ackParams, 'optionalAccess', _606 => _606.requestId])) {
+        if (!_optionalChain([ackParams, 'optionalAccess', _648 => _648.requestId])) {
           if (shouldRespond) {
             return createErrorResponse(
               id,
@@ -17439,7 +18792,7 @@ async function handleSingleRequest(request, adapter) {
       }
       case RPC_METHODS.CHANGES_DECISION: {
         const decisionParams = params;
-        if (!_optionalChain([decisionParams, 'optionalAccess', _607 => _607.batchId]) || !_optionalChain([decisionParams, 'optionalAccess', _608 => _608.action])) {
+        if (!_optionalChain([decisionParams, 'optionalAccess', _649 => _649.batchId]) || !_optionalChain([decisionParams, 'optionalAccess', _650 => _650.action])) {
           if (shouldRespond) {
             return createErrorResponse(
               id,
@@ -17459,7 +18812,7 @@ async function handleSingleRequest(request, adapter) {
       }
       case RPC_METHODS.INSTALL_SKILL: {
         const installParams = params;
-        if (!_optionalChain([installParams, 'optionalAccess', _609 => _609.skillName]) || !_optionalChain([installParams, 'optionalAccess', _610 => _610.scope])) {
+        if (!_optionalChain([installParams, 'optionalAccess', _651 => _651.skillName]) || !_optionalChain([installParams, 'optionalAccess', _652 => _652.scope])) {
           if (shouldRespond) {
             return createErrorResponse(
               id,
@@ -17504,20 +18857,20 @@ async function handleSingleRequest(request, adapter) {
 process.title = "autohand";
 function getGitCommit() {
   if (true) {
-    return "5392e8c";
+    return "fc318c0";
   }
   try {
     return _child_process.execSync.call(void 0, "git rev-parse --short HEAD", { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }).trim();
-  } catch (e86) {
+  } catch (e96) {
     return "unknown";
   }
 }
 function getVersionString() {
   const commit = getGitCommit();
-  return `${_chunkXJZYEURAcjs.package_default.version} (${commit})`;
+  return `${_chunkJYTXG6OVcjs.package_default.version} (${commit})`;
 }
 async function validateAuthOnStartup(config) {
-  if (!_optionalChain([config, 'access', _611 => _611.auth, 'optionalAccess', _612 => _612.token])) {
+  if (!_optionalChain([config, 'access', _653 => _653.auth, 'optionalAccess', _654 => _654.token])) {
     return void 0;
   }
   if (config.auth.expiresAt) {
@@ -17526,7 +18879,7 @@ async function validateAuthOnStartup(config) {
       config.auth = void 0;
       try {
         await _chunkQMVTT55Ycjs.saveConfig.call(void 0, config);
-      } catch (e87) {
+      } catch (e97) {
       }
       return void 0;
     }
@@ -17538,16 +18891,16 @@ async function validateAuthOnStartup(config) {
       config.auth = void 0;
       try {
         await _chunkQMVTT55Ycjs.saveConfig.call(void 0, config);
-      } catch (e88) {
+      } catch (e98) {
       }
       return void 0;
     }
     if (result.user && config.auth) {
       config.auth.user = result.user;
     }
-    return _optionalChain([config, 'access', _613 => _613.auth, 'optionalAccess', _614 => _614.user]);
-  } catch (e89) {
-    return _optionalChain([config, 'access', _615 => _615.auth, 'optionalAccess', _616 => _616.user]);
+    return _optionalChain([config, 'access', _655 => _655.auth, 'optionalAccess', _656 => _656.user]);
+  } catch (e99) {
+    return _optionalChain([config, 'access', _657 => _657.auth, 'optionalAccess', _658 => _658.user]);
   }
 }
 process.on("uncaughtException", (err) => {
@@ -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 (0, _commander.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 Promise.resolve().then(() => _interopRequireWildcard(require("./login-QNJ5C42G.cjs")));
+    const config = await _chunkQMVTT55Ycjs.loadConfig.call(void 0, opts.config);
+    await login({ config });
+    process.exit(0);
+  }
+  if (opts.logout) {
+    const { logout } = await Promise.resolve().then(() => _interopRequireWildcard(require("./logout-MVUP7GPU.cjs")));
+    const config = await _chunkQMVTT55Ycjs.loadConfig.call(void 0, opts.config);
+    await logout({ config });
+    process.exit(0);
+  }
+  if (opts.setup) {
+    const config = await _chunkQMVTT55Ycjs.loadConfig.call(void 0, opts.config);
+    const workspaceRoot = _chunkQMVTT55Ycjs.resolveWorkspaceRoot.call(void 0, config, opts.path);
+    const wizard = new SetupWizard(workspaceRoot, config);
+    const result = await wizard.run({ skipWelcome: false });
+    if (result.cancelled) {
+      console.log(_chalk2.default.gray("\nSetup cancelled."));
+      process.exit(0);
+    }
+    if (result.success) {
+      const newConfig = { ...config, ...result.config };
+      await _chunkQMVTT55Ycjs.saveConfig.call(void 0, newConfig);
+      console.log(_chalk2.default.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 Promise.resolve().then(() => _interopRequireWildcard(require("./login-QNJ5C42G.cjs")));
+  const config = await _chunkQMVTT55Ycjs.loadConfig.call(void 0, );
+  await login({ config });
+  process.exit(0);
+});
+program.command("logout").description("Sign out of your Autohand account").action(async () => {
+  const { logout } = await Promise.resolve().then(() => _interopRequireWildcard(require("./logout-MVUP7GPU.cjs")));
+  const config = await _chunkQMVTT55Ycjs.loadConfig.call(void 0, );
+  await logout({ config });
+  process.exit(0);
+});
 async function runCLI(options) {
   const statusPanel = null;
   try {
     let config = await _chunkQMVTT55Ycjs.loadConfig.call(void 0, options.config);
+    const workspaceRoot = _chunkQMVTT55Ycjs.resolveWorkspaceRoot.call(void 0, config, options.path);
     const providerName = _nullishCoalesce(config.provider, () => ( "openrouter"));
     const providerConfig = _chunkQMVTT55Ycjs.getProviderConfig.call(void 0, config, providerName);
     if (!providerConfig) {
-      if (config.isNewConfig) {
-        console.log(_chalk2.default.cyan("\n\u2728 Welcome to Autohand!\n"));
-        console.log(_chalk2.default.gray(`Config created at: ${config.configPath}
-`));
-      }
-      console.log(_chalk2.default.yellow(`No ${providerName} API key configured.
-`));
-      let apiKey;
-      try {
-        const result = await _enquirer2.default.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 (_optionalChain([error, 'optionalAccess', _617 => _617.code]) === "ERR_USE_AFTER_CLOSE" || _optionalChain([error, 'optionalAccess', _618 => _618.message, 'optionalAccess', _619 => _619.includes, 'call', _620 => _620("cancelled")])) {
-          console.log(_chalk2.default.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(_chalk2.default.gray("\nSetup cancelled."));
+        process.exit(0);
       }
-      if (providerName === "openrouter") {
-        config.openrouter = {
-          ...config.openrouter,
-          apiKey: apiKey.trim(),
-          baseUrl: _optionalChain([config, 'access', _621 => _621.openrouter, 'optionalAccess', _622 => _622.baseUrl]) || "https://openrouter.ai/api/v1",
-          model: _optionalChain([config, 'access', _623 => _623.openrouter, 'optionalAccess', _624 => _624.model]) || "anthropic/claude-sonnet-4-20250514"
-        };
-      } else if (providerName === "openai") {
-        config.openai = {
-          ...config.openai,
-          apiKey: apiKey.trim(),
-          model: _optionalChain([config, 'access', _625 => _625.openai, 'optionalAccess', _626 => _626.model]) || "gpt-4o"
-        };
+      if (result.success) {
+        config = { ...config, ...result.config };
+        await _chunkQMVTT55Ycjs.saveConfig.call(void 0, config);
+        console.log();
       }
-      await _chunkQMVTT55Ycjs.saveConfig.call(void 0, config);
-      console.log(_chalk2.default.green("\u2713 API key saved to config\n"));
     }
-    const workspaceRoot = _chunkQMVTT55Ycjs.resolveWorkspaceRoot.call(void 0, config, options.path);
     const safetyCheck = checkWorkspaceSafety(workspaceRoot);
     if (!safetyCheck.safe) {
       printDangerousWorkspaceWarning(workspaceRoot, safetyCheck);
@@ -17664,8 +19024,8 @@ async function runCLI(options) {
       options
     };
     const authUser = await validateAuthOnStartup(config);
-    const versionCheck = _optionalChain([config, 'access', _627 => _627.ui, 'optionalAccess', _628 => _628.checkForUpdates]) !== false ? await checkForUpdates(_chunkXJZYEURAcjs.package_default.version, {
-      checkIntervalHours: _nullishCoalesce(_optionalChain([config, 'access', _629 => _629.ui, 'optionalAccess', _630 => _630.updateCheckInterval]), () => ( 24))
+    const versionCheck = _optionalChain([config, 'access', _659 => _659.ui, 'optionalAccess', _660 => _660.checkForUpdates]) !== false ? await checkForUpdates(_chunkJYTXG6OVcjs.package_default.version, {
+      checkIntervalHours: _nullishCoalesce(_optionalChain([config, 'access', _661 => _661.ui, 'optionalAccess', _662 => _662.updateCheckInterval]), () => ( 24))
     }) : null;
     printBanner();
     printWelcome(runtime, authUser, versionCheck);
@@ -17697,6 +19057,7 @@ async function runCLI(options) {
     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 {
@@ -17716,7 +19077,7 @@ function printBanner() {
     return;
   }
   if (process.stdout.isTTY) {
-    console.log(_chalk2.default.gray(ASCII_FRIEND));
+    console.log(_chalk2.default.gray(ASCII_FRIEND2));
   } else {
     console.log("autohand");
   }
@@ -17728,8 +19089,8 @@ function printWelcome(runtime, authUser, versionCheck) {
   const model = (() => {
     try {
       const settings = _chunkQMVTT55Ycjs.getProviderConfig.call(void 0, runtime.config);
-      return _nullishCoalesce(_nullishCoalesce(runtime.options.model, () => ( _optionalChain([settings, 'optionalAccess', _631 => _631.model]))), () => ( "unknown"));
-    } catch (e90) {
+      return _nullishCoalesce(_nullishCoalesce(runtime.options.model, () => ( _optionalChain([settings, 'optionalAccess', _663 => _663.model]))), () => ( "unknown"));
+    } catch (e100) {
       return _nullishCoalesce(runtime.options.model, () => ( "unknown"));
     }
   })();
@@ -17743,7 +19104,7 @@ function printWelcome(runtime, authUser, versionCheck) {
     }
   }
   console.log(versionLine);
-  if (_optionalChain([versionCheck, 'optionalAccess', _632 => _632.updateAvailable])) {
+  if (_optionalChain([versionCheck, 'optionalAccess', _664 => _664.updateAvailable])) {
     console.log(_chalk2.default.gray("  \u21B3 Run: ") + _chalk2.default.cyan("curl -fsSL https://autohand.ai/install.sh | sh"));
   }
   if (authUser) {
@@ -17791,18 +19152,18 @@ async function displayPermissions(opts) {
   const { loadLocalProjectSettings } = await Promise.resolve().then(() => _interopRequireWildcard(require("./localProjectPermissions-75X3ZGKH.cjs")));
   const localSettings = await loadLocalProjectSettings(workspaceRoot);
   const mergedSettings = {
-    mode: _nullishCoalesce(_nullishCoalesce(_optionalChain([localSettings, 'optionalAccess', _633 => _633.permissions, 'optionalAccess', _634 => _634.mode]), () => ( _optionalChain([config, 'access', _635 => _635.permissions, 'optionalAccess', _636 => _636.mode]))), () => ( "interactive")),
+    mode: _nullishCoalesce(_nullishCoalesce(_optionalChain([localSettings, 'optionalAccess', _665 => _665.permissions, 'optionalAccess', _666 => _666.mode]), () => ( _optionalChain([config, 'access', _667 => _667.permissions, 'optionalAccess', _668 => _668.mode]))), () => ( "interactive")),
     whitelist: [
-      ..._nullishCoalesce(_optionalChain([config, 'access', _637 => _637.permissions, 'optionalAccess', _638 => _638.whitelist]), () => ( [])),
-      ..._nullishCoalesce(_optionalChain([localSettings, 'optionalAccess', _639 => _639.permissions, 'optionalAccess', _640 => _640.whitelist]), () => ( []))
+      ..._nullishCoalesce(_optionalChain([config, 'access', _669 => _669.permissions, 'optionalAccess', _670 => _670.whitelist]), () => ( [])),
+      ..._nullishCoalesce(_optionalChain([localSettings, 'optionalAccess', _671 => _671.permissions, 'optionalAccess', _672 => _672.whitelist]), () => ( []))
     ],
     blacklist: [
-      ..._nullishCoalesce(_optionalChain([config, 'access', _641 => _641.permissions, 'optionalAccess', _642 => _642.blacklist]), () => ( [])),
-      ..._nullishCoalesce(_optionalChain([localSettings, 'optionalAccess', _643 => _643.permissions, 'optionalAccess', _644 => _644.blacklist]), () => ( []))
+      ..._nullishCoalesce(_optionalChain([config, 'access', _673 => _673.permissions, 'optionalAccess', _674 => _674.blacklist]), () => ( [])),
+      ..._nullishCoalesce(_optionalChain([localSettings, 'optionalAccess', _675 => _675.permissions, 'optionalAccess', _676 => _676.blacklist]), () => ( []))
     ],
     rules: [
-      ..._nullishCoalesce(_optionalChain([config, 'access', _645 => _645.permissions, 'optionalAccess', _646 => _646.rules]), () => ( [])),
-      ..._nullishCoalesce(_optionalChain([localSettings, 'optionalAccess', _647 => _647.permissions, 'optionalAccess', _648 => _648.rules]), () => ( []))
+      ..._nullishCoalesce(_optionalChain([config, 'access', _677 => _677.permissions, 'optionalAccess', _678 => _678.rules]), () => ( [])),
+      ..._nullishCoalesce(_optionalChain([localSettings, 'optionalAccess', _679 => _679.permissions, 'optionalAccess', _680 => _680.rules]), () => ( []))
     ]
   };
   const manager = new PermissionManager2({ settings: mergedSettings });
@@ -17934,13 +19295,13 @@ async function runAutoMode(opts) {
   }
   const { AutomodeManager, getAutomodeOptions } = await Promise.resolve().then(() => _interopRequireWildcard(require("./AutomodeManager-TJSW2SQY.cjs")));
   const { HookManager: HookManager2 } = await Promise.resolve().then(() => _interopRequireWildcard(require("./HookManager-EOMUXKJ4.cjs")));
-  const { SessionManager: SessionManager2 } = await Promise.resolve().then(() => _interopRequireWildcard(require("./SessionManager-VZNWGX4O.cjs")));
+  const { SessionManager: SessionManager2 } = await Promise.resolve().then(() => _interopRequireWildcard(require("./SessionManager-M5ZLCLCW.cjs")));
   const { MemoryManager: MemoryManager2 } = await Promise.resolve().then(() => _interopRequireWildcard(require("./MemoryManager-WO3KUZVA.cjs")));
-  const readline5 = await Promise.resolve().then(() => _interopRequireWildcard(require("readline")));
+  const readline3 = await Promise.resolve().then(() => _interopRequireWildcard(require("readline")));
   const llmProvider = ProviderFactory.create(config);
   const files = new FileActionManager(workspaceRoot);
   const providerName = _nullishCoalesce(config.provider, () => ( "openrouter"));
-  const modelName = _nullishCoalesce(_nullishCoalesce(opts.model, () => ( _optionalChain([config, 'access', _649 => _649[providerName], 'optionalAccess', _650 => _650.model]))), () => ( "unknown"));
+  const modelName = _nullishCoalesce(_nullishCoalesce(opts.model, () => ( _optionalChain([config, 'access', _681 => _681[providerName], 'optionalAccess', _682 => _682.model]))), () => ( "unknown"));
   const sessionManager = new SessionManager2();
   await sessionManager.initialize();
   const session = await sessionManager.createSession(workspaceRoot, modelName);
@@ -17965,7 +19326,7 @@ async function runAutoMode(opts) {
   console.log(_chalk2.default.gray("Worktree Isolation:"), _chalk2.default.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") {
@@ -18022,11 +19383,44 @@ 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: ${_optionalChain([opts, 'access', _651 => _651.autoMode, 'optionalAccess', _652 => _652.slice, 'call', _653 => _653(0, 50)])}...`);
+      console.log(_chalk2.default.gray(`
+\u{1F4CA} Auto-mode ${statusText} after ${finalState.currentIteration} iterations`));
+    }
+    console.log(_chalk2.default.cyan("\n\u{1F504} Auto-mode finished. You can continue working interactively.\n"));
+    console.log(_chalk2.default.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 = _optionalChain([finalState, 'optionalAccess', _683 => _683.status]) === "completed" ? "completed" : `ended (${_optionalChain([finalState, 'optionalAccess', _684 => _684.status])})`;
+      await sessionManager.closeSession(`Auto-mode ${statusText} after ${_nullishCoalesce(_optionalChain([finalState, 'optionalAccess', _685 => _685.currentIteration]), () => ( 0))} iterations: ${_optionalChain([opts, 'access', _686 => _686.autoMode, 'optionalAccess', _687 => _687.slice, 'call', _688 => _688(0, 50)])}...`);
       console.log(_chalk2.default.gray(`
 \u{1F4C1} Session saved: ${session.metadata.sessionId}`));
+      process.exit(_optionalChain([finalState, 'optionalAccess', _689 => _689.status]) === "completed" ? 0 : 1);
     }
-    process.exit(_optionalChain([finalState, 'optionalAccess', _654 => _654.status]) === "completed" ? 0 : 1);
+    console.log(_chalk2.default.cyan("\n\u25B6\uFE0F Continuing in interactive mode...\n"));
+    await agent.runInteractive();
   } catch (error) {
     if (process.stdin.isTTY) {
       process.stdin.setRawMode(false);