autohand-cli 0.6.12 → 0.7.2

package/dist/index.js

@@ -1,11 +1,23 @@
 #!/usr/bin/env node
+import {
+  PermissionManager
+} from "./chunk-YMP7AGNT.js";
+import {
+  SessionManager
+} from "./chunk-2FLBGPE3.js";
+import {
+  MemoryManager
+} from "./chunk-4L5WYXHN.js";
 import {
   SkillsRegistry
 } from "./chunk-SKU4M27Z.js";
+import {
+  HookManager
+} from "./chunk-UOLJZFPJ.js";
 import {
   installMetadata,
   metadata as metadata23
-} from "./chunk-MFLRXVKU.js";
+} from "./chunk-HUE3GT5M.js";
 import {
   metadata as metadata24
 } from "./chunk-NGSLABLS.js";
@@ -14,8 +26,8 @@ import {
   metadata as metadata25
 } from "./chunk-ZYHQ652D.js";
 import {
-  PermissionManager
-} from "./chunk-YMP7AGNT.js";
+  metadata as metadata26
+} from "./chunk-CXZEPTRI.js";
 import "./chunk-27ISZOFA.js";
 import {
   metadata as metadata15
@@ -29,7 +41,7 @@ import {
 import {
   metadata as metadata18,
   package_default
-} from "./chunk-A2TFZJD4.js";
+} from "./chunk-LCCJ26QR.js";
 import {
   metadata as metadata19
 } from "./chunk-6XITU2RU.js";
@@ -53,7 +65,7 @@ import {
 } from "./chunk-YDH2BMEN.js";
 import {
   metadata as metadata22
-} from "./chunk-SFT6BEYU.js";
+} from "./chunk-BAFJQUWR.js";
 import {
   metadata as metadata7
 } from "./chunk-SVLBJMYO.js";
@@ -106,6 +118,9 @@ import {
 import {
   metadata as metadata6
 } from "./chunk-QJ53OSGF.js";
+import {
+  __require
+} from "./chunk-3RG5ZIWI.js";
 
 // src/index.ts
 import "dotenv/config";
@@ -326,12 +341,251 @@ function printStartupCheckResults(results, verbose = false) {
   }
 }
 
-// src/utils/versionCheck.ts
-import fs2 from "fs-extra";
-import path from "path";
+// src/startup/workspaceSafety.ts
 import os2 from "os";
+import path from "path";
+import fs2 from "fs-extra";
+var DANGEROUS_PATHS = {
+  // Filesystem roots (Unix and Windows)
+  roots: ["/", "C:\\", "D:\\", "E:\\", "F:\\", "G:\\"],
+  // System directories (Unix/Linux)
+  unix: [
+    "/etc",
+    "/var",
+    "/usr",
+    "/opt",
+    "/bin",
+    "/sbin",
+    "/lib",
+    "/lib64",
+    "/root",
+    "/sys",
+    "/proc",
+    "/dev",
+    "/boot",
+    "/run",
+    "/snap"
+  ],
+  // System directories (macOS)
+  macos: [
+    "/System",
+    "/Library",
+    "/Applications",
+    "/private",
+    "/cores",
+    "/Volumes"
+  ],
+  // System directories (Windows)
+  windows: [
+    "C:\\Windows",
+    "C:\\Program Files",
+    "C:\\Program Files (x86)",
+    "C:\\ProgramData",
+    "C:\\Recovery",
+    "C:\\$Recycle.Bin"
+  ],
+  // WSL mount points (Windows drives mounted in WSL)
+  wsl: ["/mnt/c", "/mnt/d", "/mnt/e", "/mnt/f"]
+};
+function normalizePath(inputPath) {
+  let normalized = path.resolve(inputPath);
+  try {
+    normalized = fs2.realpathSync(normalized);
+  } catch {
+  }
+  if (normalized.length > 1 && normalized.endsWith(path.sep)) {
+    normalized = normalized.slice(0, -1);
+  }
+  return normalized;
+}
+function pathsEqual(path1, path22) {
+  const normalized1 = normalizePath(path1);
+  const normalized2 = normalizePath(path22);
+  if (process.platform === "darwin" || process.platform === "win32") {
+    return normalized1.toLowerCase() === normalized2.toLowerCase();
+  }
+  return normalized1 === normalized2;
+}
+function isFilesystemRoot(workspacePath) {
+  const normalized = normalizePath(workspacePath);
+  if (normalized === "/") {
+    return true;
+  }
+  if (process.platform === "win32") {
+    if (/^[A-Za-z]:[\\/]?$/.test(normalized)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isHomeDirectory(workspacePath) {
+  const homeDir = os2.homedir();
+  return pathsEqual(workspacePath, homeDir);
+}
+function isParentOfHome(workspacePath) {
+  const homeDir = os2.homedir();
+  const normalized = normalizePath(workspacePath);
+  const normalizedHome = normalizePath(homeDir);
+  if (process.platform === "darwin" || process.platform === "win32") {
+    return normalizedHome.toLowerCase().startsWith(normalized.toLowerCase() + path.sep);
+  }
+  return normalizedHome.startsWith(normalized + path.sep);
+}
+function isSystemDirectory(workspacePath) {
+  const normalized = normalizePath(workspacePath);
+  let dangerousPaths = [...DANGEROUS_PATHS.roots];
+  if (process.platform === "darwin") {
+    dangerousPaths = [...dangerousPaths, ...DANGEROUS_PATHS.unix, ...DANGEROUS_PATHS.macos];
+  } else if (process.platform === "win32") {
+    dangerousPaths = [...dangerousPaths, ...DANGEROUS_PATHS.windows];
+  } else {
+    dangerousPaths = [...dangerousPaths, ...DANGEROUS_PATHS.unix, ...DANGEROUS_PATHS.wsl];
+  }
+  for (const dangerous of dangerousPaths) {
+    if (pathsEqual(normalized, dangerous)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isWslWindowsHome(workspacePath) {
+  if (process.platform !== "linux") {
+    return false;
+  }
+  const normalized = normalizePath(workspacePath);
+  for (const wslMount of DANGEROUS_PATHS.wsl) {
+    if (pathsEqual(normalized, wslMount)) {
+      return true;
+    }
+  }
+  const wslUsersPattern = /^\/mnt\/[a-z]\/users(\/[^/]+)?$/i;
+  if (wslUsersPattern.test(normalized)) {
+    return true;
+  }
+  return false;
+}
+function getDangerReason(workspacePath) {
+  const normalized = normalizePath(workspacePath);
+  if (isFilesystemRoot(workspacePath)) {
+    return "This is the filesystem root directory.";
+  }
+  if (isHomeDirectory(workspacePath)) {
+    return "This is your home directory.";
+  }
+  if (isParentOfHome(workspacePath)) {
+    return "This directory contains user home directories.";
+  }
+  if (isWslWindowsHome(workspacePath)) {
+    return "This is a Windows system directory accessed via WSL.";
+  }
+  if (normalized.startsWith("/etc") || normalized.match(/^[A-Za-z]:\\Windows/i)) {
+    return "This is a system configuration directory.";
+  }
+  if (normalized.startsWith("/var") || normalized.match(/^[A-Za-z]:\\ProgramData/i)) {
+    return "This is a system data directory.";
+  }
+  if (normalized.startsWith("/usr") || normalized.match(/^[A-Za-z]:\\Program Files/i)) {
+    return "This is a system programs directory.";
+  }
+  if (normalized.startsWith("/System") || normalized.startsWith("/Library")) {
+    return "This is a macOS system directory.";
+  }
+  return "This directory is too broad for safe AI agent operation.";
+}
+function checkWorkspaceSafety(workspacePath) {
+  try {
+    const normalized = normalizePath(workspacePath);
+    if (isFilesystemRoot(normalized)) {
+      return {
+        safe: false,
+        reason: "This is the filesystem root directory. Running an AI agent here could modify critical system files.",
+        suggestion: "Navigate to a specific project folder and try again."
+      };
+    }
+    if (isHomeDirectory(normalized)) {
+      return {
+        safe: false,
+        reason: "This is your home directory. Running an AI agent here could modify files across your entire user account.",
+        suggestion: "Navigate to a specific project folder (e.g., ~/projects/my-app) and try again."
+      };
+    }
+    if (isParentOfHome(normalized)) {
+      return {
+        safe: false,
+        reason: "This directory contains user home directories. Running an AI agent here is too broad.",
+        suggestion: "Navigate to a specific project folder and try again."
+      };
+    }
+    if (isSystemDirectory(normalized)) {
+      return {
+        safe: false,
+        reason: getDangerReason(normalized),
+        suggestion: "Navigate to a specific project folder and try again."
+      };
+    }
+    if (isWslWindowsHome(normalized)) {
+      return {
+        safe: false,
+        reason: getDangerReason(normalized),
+        suggestion: "Navigate to a specific project folder and try again."
+      };
+    }
+    return { safe: true };
+  } catch (error) {
+    console.warn(`Warning: Could not verify workspace safety for "${workspacePath}": ${error}`);
+    return { safe: true };
+  }
+}
+function printDangerousWorkspaceWarning(workspacePath, result) {
+  const chalk16 = __require("chalk");
+  const boxWidth = 65;
+  const horizontalLine = "\u2500".repeat(boxWidth - 2);
+  console.log();
+  console.log(chalk16.red(`\u250C${horizontalLine}\u2510`));
+  console.log(chalk16.red(`\u2502`) + chalk16.yellow.bold("  \u26A0\uFE0F  Unsafe Workspace Directory") + " ".repeat(boxWidth - 35) + chalk16.red("\u2502"));
+  console.log(chalk16.red(`\u251C${horizontalLine}\u2524`));
+  console.log(chalk16.red(`\u2502`) + " ".repeat(boxWidth - 2) + chalk16.red("\u2502"));
+  console.log(chalk16.red(`\u2502`) + chalk16.white("  You're trying to run autohand in:") + " ".repeat(boxWidth - 38) + chalk16.red("\u2502"));
+  const pathLine = `  ${workspacePath}`;
+  const truncatedPath = pathLine.length > boxWidth - 4 ? pathLine.slice(0, boxWidth - 7) + "..." : pathLine;
+  console.log(chalk16.red(`\u2502`) + chalk16.cyan(truncatedPath) + " ".repeat(Math.max(0, boxWidth - 2 - truncatedPath.length)) + chalk16.red("\u2502"));
+  console.log(chalk16.red(`\u2502`) + " ".repeat(boxWidth - 2) + chalk16.red("\u2502"));
+  if (result.reason) {
+    const reasonWords = result.reason.split(" ");
+    let currentLine = "  ";
+    for (const word of reasonWords) {
+      if (currentLine.length + word.length + 1 > boxWidth - 4) {
+        const paddedLine = currentLine + " ".repeat(Math.max(0, boxWidth - 2 - currentLine.length));
+        console.log(chalk16.red(`\u2502`) + chalk16.white(paddedLine) + chalk16.red("\u2502"));
+        currentLine = "  ";
+      }
+      currentLine += (currentLine === "  " ? "" : " ") + word;
+    }
+    if (currentLine.length > 2) {
+      const paddedLine = currentLine + " ".repeat(Math.max(0, boxWidth - 2 - currentLine.length));
+      console.log(chalk16.red(`\u2502`) + chalk16.white(paddedLine) + chalk16.red("\u2502"));
+    }
+  }
+  console.log(chalk16.red(`\u2502`) + " ".repeat(boxWidth - 2) + chalk16.red("\u2502"));
+  console.log(chalk16.red(`\u2502`) + chalk16.white("  Please navigate to a specific project folder:") + " ".repeat(boxWidth - 50) + chalk16.red("\u2502"));
+  console.log(chalk16.red(`\u2502`) + " ".repeat(boxWidth - 2) + chalk16.red("\u2502"));
+  console.log(chalk16.red(`\u2502`) + chalk16.cyan("    cd ~/projects/my-app") + " ".repeat(boxWidth - 27) + chalk16.red("\u2502"));
+  console.log(chalk16.red(`\u2502`) + chalk16.cyan("    autohand") + " ".repeat(boxWidth - 15) + chalk16.red("\u2502"));
+  console.log(chalk16.red(`\u2502`) + " ".repeat(boxWidth - 2) + chalk16.red("\u2502"));
+  console.log(chalk16.red(`\u2502`) + chalk16.white("  Or specify a path directly:") + " ".repeat(boxWidth - 32) + chalk16.red("\u2502"));
+  console.log(chalk16.red(`\u2502`) + " ".repeat(boxWidth - 2) + chalk16.red("\u2502"));
+  console.log(chalk16.red(`\u2502`) + chalk16.cyan("    autohand --path ~/projects/my-app") + " ".repeat(boxWidth - 40) + chalk16.red("\u2502"));
+  console.log(chalk16.red(`\u2502`) + " ".repeat(boxWidth - 2) + chalk16.red("\u2502"));
+  console.log(chalk16.red(`\u2514${horizontalLine}\u2518`));
+  console.log();
+}
+
+// src/utils/versionCheck.ts
+import fs3 from "fs-extra";
+import path2 from "path";
+import os3 from "os";
 var GITHUB_API_URL = "https://api.github.com/repos/autohandai/code-cli/releases/latest";
-var CACHE_FILE = path.join(os2.homedir(), ".autohand", "version-check.json");
+var CACHE_FILE = path2.join(os3.homedir(), ".autohand", "version-check.json");
 var DEFAULT_CHECK_INTERVAL_HOURS = 24;
 var REQUEST_TIMEOUT_MS = 3e3;
 function compareVersions(a, b) {
@@ -356,8 +610,8 @@ function compareVersions(a, b) {
 }
 async function readCache() {
   try {
-    if (await fs2.pathExists(CACHE_FILE)) {
-      const data = await fs2.readJson(CACHE_FILE);
+    if (await fs3.pathExists(CACHE_FILE)) {
+      const data = await fs3.readJson(CACHE_FILE);
       return data;
     }
   } catch {
@@ -366,8 +620,8 @@ async function readCache() {
 }
 async function writeCache(cache) {
   try {
-    await fs2.ensureDir(path.dirname(CACHE_FILE));
-    await fs2.writeJson(CACHE_FILE, cache, { spaces: 2 });
+    await fs3.ensureDir(path2.dirname(CACHE_FILE));
+    await fs3.writeJson(CACHE_FILE, cache, { spaces: 2 });
   } catch {
   }
 }
@@ -453,21 +707,21 @@ async function checkForUpdates(currentVersion, options = {}) {
 }
 
 // src/actions/filesystem.ts
-import fs4 from "fs-extra";
-import path3 from "path";
+import fs5 from "fs-extra";
+import path4 from "path";
 import { spawnSync as spawnSync2 } from "child_process";
 import { applyPatch as applyUnifiedPatch } from "diff";
 
 // src/utils/gitIgnore.ts
-import fs3 from "fs-extra";
-import path2 from "path";
+import fs4 from "fs-extra";
+import path3 from "path";
 import ignore from "ignore";
 var GitIgnoreParser = class {
   constructor(projectRoot, extraPatterns) {
     this.extraPatterns = extraPatterns;
     this.cache = /* @__PURE__ */ new Map();
     this.processedExtraPatterns = [];
-    this.projectRoot = path2.resolve(projectRoot);
+    this.projectRoot = path3.resolve(projectRoot);
     if (this.extraPatterns?.length) {
       this.processedExtraPatterns = this.processPatterns(this.extraPatterns, ".");
     }
@@ -476,11 +730,11 @@ var GitIgnoreParser = class {
     if (!filePath) {
       return false;
     }
-    const absoluteFilePath = path2.resolve(this.projectRoot, filePath);
+    const absoluteFilePath = path3.resolve(this.projectRoot, filePath);
     if (!absoluteFilePath.startsWith(this.projectRoot)) {
       return false;
     }
-    const relativePath = path2.relative(this.projectRoot, absoluteFilePath);
+    const relativePath = path3.relative(this.projectRoot, absoluteFilePath);
     if (!relativePath || relativePath.startsWith("..")) {
       return false;
     }
@@ -488,20 +742,20 @@ var GitIgnoreParser = class {
     const ig = ignore();
     ig.add(".git");
     if (this.globalPatterns === void 0) {
-      const excludeFile = path2.join(this.projectRoot, ".git", "info", "exclude");
-      this.globalPatterns = fs3.existsSync(excludeFile) ? this.loadPatternsForFile(excludeFile) : [];
+      const excludeFile = path3.join(this.projectRoot, ".git", "info", "exclude");
+      this.globalPatterns = fs4.existsSync(excludeFile) ? this.loadPatternsForFile(excludeFile) : [];
     }
     ig.add(this.globalPatterns);
-    const pathParts = relativePath.split(path2.sep);
+    const pathParts = relativePath.split(path3.sep);
     const dirsToVisit = [];
     let current = this.projectRoot;
     dirsToVisit.push(current);
     for (let i = 0; i < pathParts.length - 1; i++) {
-      current = path2.join(current, pathParts[i]);
+      current = path3.join(current, pathParts[i]);
       dirsToVisit.push(current);
     }
     for (const dir of dirsToVisit) {
-      const relativeDir = path2.relative(this.projectRoot, dir);
+      const relativeDir = path3.relative(this.projectRoot, dir);
       if (relativeDir) {
         const normalizedDir = relativeDir.replace(/\\/g, "/");
         const igPlusExtras = ignore().add(ig).add(this.processedExtraPatterns);
@@ -512,8 +766,8 @@ var GitIgnoreParser = class {
       if (this.cache.has(dir)) {
         ig.add(this.cache.get(dir) ?? []);
       } else {
-        const gitignorePath = path2.join(dir, ".gitignore");
-        if (fs3.existsSync(gitignorePath)) {
+        const gitignorePath = path3.join(dir, ".gitignore");
+        if (fs4.existsSync(gitignorePath)) {
           const patterns = this.loadPatternsForFile(gitignorePath);
           this.cache.set(dir, patterns);
           ig.add(patterns);
@@ -528,12 +782,12 @@ var GitIgnoreParser = class {
   loadPatternsForFile(patternsFilePath) {
     let content = "";
     try {
-      content = fs3.readFileSync(patternsFilePath, "utf8");
+      content = fs4.readFileSync(patternsFilePath, "utf8");
     } catch {
       return [];
     }
-    const isExcludeFile = patternsFilePath.endsWith(path2.join(".git", "info", "exclude"));
-    const relativeBaseDir = isExcludeFile ? "." : path2.dirname(path2.relative(this.projectRoot, patternsFilePath)).split(path2.sep).join(path2.posix.sep);
+    const isExcludeFile = patternsFilePath.endsWith(path3.join(".git", "info", "exclude"));
+    const relativeBaseDir = isExcludeFile ? "." : path3.dirname(path3.relative(this.projectRoot, patternsFilePath)).split(path3.sep).join(path3.posix.sep);
     const rawPatterns = content.split("\n");
     return this.processPatterns(rawPatterns, relativeBaseDir);
   }
@@ -556,9 +810,9 @@ var GitIgnoreParser = class {
     let newPattern = p;
     if (relativeBaseDir && relativeBaseDir !== ".") {
       if (!isAnchored && !p.includes("/")) {
-        newPattern = path2.posix.join("**", p);
+        newPattern = path3.posix.join("**", p);
       }
-      newPattern = path2.posix.join(relativeBaseDir, newPattern);
+      newPattern = path3.posix.join(relativeBaseDir, newPattern);
       if (!newPattern.startsWith("/")) {
         newPattern = "/" + newPattern;
       }
@@ -597,7 +851,7 @@ var FileActionManager = class {
     this.onBatchChange = null;
     this.currentToolId = "";
     this.currentToolName = "";
-    this.workspaceRoot = path3.resolve(workspaceRoot);
+    this.workspaceRoot = path4.resolve(workspaceRoot);
   }
   /**
    * Enter preview mode - changes will be batched instead of written
@@ -662,10 +916,10 @@ var FileActionManager = class {
       try {
         const fullPath = this.resolvePath(change.filePath);
         if (change.changeType === "delete") {
-          await fs4.remove(fullPath);
+          await fs5.remove(fullPath);
         } else {
-          await fs4.ensureDir(path3.dirname(fullPath));
-          await fs4.writeFile(fullPath, change.proposedContent, "utf8");
+          await fs5.ensureDir(path4.dirname(fullPath));
+          await fs5.writeFile(fullPath, change.proposedContent, "utf8");
         }
         applied.push(change.id);
       } catch (err) {
@@ -704,17 +958,17 @@ var FileActionManager = class {
   }
   async readFile(target) {
     const filePath = this.resolvePath(target);
-    const exists = await fs4.pathExists(filePath);
+    const exists = await fs5.pathExists(filePath);
     if (!exists) {
       throw new Error(`File ${target} not found in workspace.`);
     }
-    const stats = await fs4.stat(filePath);
+    const stats = await fs5.stat(filePath);
     if (stats.size > FILE_LIMITS.MAX_READ_SIZE) {
       const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
       const limitMB = (FILE_LIMITS.MAX_READ_SIZE / 1024 / 1024).toFixed(0);
       throw new Error(`File ${target} is too large (${sizeMB}MB). Maximum allowed: ${limitMB}MB`);
     }
-    return fs4.readFile(filePath, "utf8");
+    return fs5.readFile(filePath, "utf8");
   }
   async writeFile(target, contents, description) {
     const contentSize = Buffer.byteLength(contents, "utf8");
@@ -724,8 +978,8 @@ var FileActionManager = class {
       throw new Error(`Content too large to write (${sizeMB}MB). Maximum allowed: ${limitMB}MB`);
     }
     const filePath = this.resolvePath(target);
-    const exists = await fs4.pathExists(filePath);
-    const previous = exists ? await fs4.readFile(filePath, "utf8") : "";
+    const exists = await fs5.pathExists(filePath);
+    const previous = exists ? await fs5.readFile(filePath, "utf8") : "";
     const changeType = exists ? "modify" : "create";
     if (this.previewMode) {
       this.addBatchedChange(
@@ -737,12 +991,12 @@ var FileActionManager = class {
       );
       return;
     }
-    await fs4.ensureDir(path3.dirname(filePath));
+    await fs5.ensureDir(path4.dirname(filePath));
     if (this.undoStack.length >= FILE_LIMITS.MAX_UNDO_STACK) {
       this.undoStack.shift();
     }
     this.undoStack.push({ absolutePath: filePath, previousContents: previous });
-    await fs4.writeFile(filePath, contents, "utf8");
+    await fs5.writeFile(filePath, contents, "utf8");
   }
   async appendFile(target, contents) {
     const current = await this.readFileSafe(target);
@@ -766,14 +1020,14 @@ var FileActionManager = class {
       return;
     }
     this.undoStack.push({ absolutePath: filePath, previousContents: current });
-    await fs4.writeFile(filePath, updated, "utf8");
+    await fs5.writeFile(filePath, updated, "utf8");
   }
   async undoLast() {
     const entry = this.undoStack.pop();
     if (!entry) {
       throw new Error("Undo stack is empty");
     }
-    await fs4.writeFile(entry.absolutePath, entry.previousContents, "utf8");
+    await fs5.writeFile(entry.absolutePath, entry.previousContents, "utf8");
   }
   search(query, relativePath) {
     const searchDir = this.resolvePath(relativePath ?? ".");
@@ -818,7 +1072,7 @@ var FileActionManager = class {
       const results = rgResult.stdout.trim().split("\n").filter(Boolean).slice(0, FILE_LIMITS.MAX_SEARCH_RESULTS).map((line) => {
         const [file, lineNo, ...rest] = line.split(":");
         return {
-          file: path3.relative(this.workspaceRoot, path3.join(searchDir, file)),
+          file: path4.relative(this.workspaceRoot, path4.join(searchDir, file)),
           line: Number(lineNo),
           text: rest.join(":")
         };
@@ -844,18 +1098,18 @@ var FileActionManager = class {
     while (stack.length && results.length < limit) {
       const current = stack.pop();
       if (!current) continue;
-      const relative = path3.relative(this.workspaceRoot, current);
+      const relative = path4.relative(this.workspaceRoot, current);
       const normalizedRel = relative.replace(/\\/g, "/");
-      if (path3.basename(current).startsWith(".") || ignoreFilter.isIgnored(normalizedRel)) {
+      if (path4.basename(current).startsWith(".") || ignoreFilter.isIgnored(normalizedRel)) {
         continue;
       }
       try {
-        const stats = fs4.statSync(current);
+        const stats = fs5.statSync(current);
         if (stats.isDirectory()) {
-          const entries = fs4.readdirSync(current);
+          const entries = fs5.readdirSync(current);
           for (const entry of entries) {
             if (!entry.startsWith(".")) {
-              stack.push(path3.join(current, entry));
+              stack.push(path4.join(current, entry));
             }
           }
           continue;
@@ -863,7 +1117,7 @@ var FileActionManager = class {
         if (!stats.isFile()) {
           continue;
         }
-        const ext = path3.extname(current).toLowerCase();
+        const ext = path4.extname(current).toLowerCase();
         const binaryExtensions = /* @__PURE__ */ new Set([
           ".exe",
           ".dll",
@@ -924,7 +1178,7 @@ var FileActionManager = class {
         if (normalizedRel.includes("node_modules/") || normalizedRel.includes("/dist/") || normalizedRel.includes("/build/") || normalizedRel.includes("/binaries/")) {
           continue;
         }
-        const contents = fs4.readFileSync(current, "utf8");
+        const contents = fs5.readFileSync(current, "utf8");
         const haystack = contents.toLowerCase();
         const idx = haystack.indexOf(lowerQuery);
         if (idx === -1) continue;
@@ -934,7 +1188,7 @@ var FileActionManager = class {
         const suffixEllipsis = end < contents.length ? "\u2026" : "";
         const snippet = `${prefixEllipsis}${contents.slice(start, end)}${suffixEllipsis}`;
         results.push({
-          file: normalizedRel || path3.basename(current),
+          file: normalizedRel || path4.basename(current),
           snippet
         });
       } catch {
@@ -945,39 +1199,39 @@ var FileActionManager = class {
   }
   async readFileSafe(target) {
     const filePath = this.resolvePath(target);
-    if (!await fs4.pathExists(filePath)) {
+    if (!await fs5.pathExists(filePath)) {
       return "";
     }
-    const stats = await fs4.stat(filePath);
+    const stats = await fs5.stat(filePath);
     if (stats.size > FILE_LIMITS.MAX_READ_SIZE) {
       const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
       const limitMB = (FILE_LIMITS.MAX_READ_SIZE / 1024 / 1024).toFixed(0);
       throw new Error(`File ${target} is too large (${sizeMB}MB). Maximum allowed: ${limitMB}MB`);
     }
-    return fs4.readFile(filePath, "utf8");
+    return fs5.readFile(filePath, "utf8");
   }
   resolvePath(target) {
-    const normalized = path3.isAbsolute(target) ? target : path3.join(this.workspaceRoot, target);
-    const resolved = path3.resolve(normalized);
+    const normalized = path4.isAbsolute(target) ? target : path4.join(this.workspaceRoot, target);
+    const resolved = path4.resolve(normalized);
     let realPath;
     try {
-      realPath = fs4.realpathSync(resolved);
+      realPath = fs5.realpathSync(resolved);
     } catch {
-      const parentDir = path3.dirname(resolved);
+      const parentDir = path4.dirname(resolved);
       try {
-        const realParent = fs4.realpathSync(parentDir);
-        realPath = path3.join(realParent, path3.basename(resolved));
+        const realParent = fs5.realpathSync(parentDir);
+        realPath = path4.join(realParent, path4.basename(resolved));
       } catch {
         realPath = resolved;
       }
     }
     let realWorkspaceRoot;
     try {
-      realWorkspaceRoot = fs4.realpathSync(this.workspaceRoot);
+      realWorkspaceRoot = fs5.realpathSync(this.workspaceRoot);
     } catch {
       realWorkspaceRoot = this.workspaceRoot;
     }
-    const rootWithSep = realWorkspaceRoot.endsWith(path3.sep) ? realWorkspaceRoot : `${realWorkspaceRoot}${path3.sep}`;
+    const rootWithSep = realWorkspaceRoot.endsWith(path4.sep) ? realWorkspaceRoot : `${realWorkspaceRoot}${path4.sep}`;
     if (realPath !== realWorkspaceRoot && !realPath.startsWith(rootWithSep)) {
       throw new Error(`Path ${target} escapes the workspace root ${this.workspaceRoot}`);
     }
@@ -991,28 +1245,28 @@ var FileActionManager = class {
       if (!current) {
         continue;
       }
-      const basename3 = path3.basename(current);
-      const relative = path3.relative(this.workspaceRoot, current);
+      const basename3 = path4.basename(current);
+      const relative = path4.relative(this.workspaceRoot, current);
       if (basename3.startsWith(".") || relative.includes("node_modules") || relative.startsWith("dist")) {
         continue;
       }
       try {
-        const stats = fs4.statSync(current);
+        const stats = fs5.statSync(current);
         if (stats.isDirectory()) {
-          const entries = fs4.readdirSync(current);
+          const entries = fs5.readdirSync(current);
           for (const entry of entries) {
             if (!entry.startsWith(".")) {
-              stack.push(path3.join(current, entry));
+              stack.push(path4.join(current, entry));
             }
           }
         } else if (stats.isFile()) {
-          const contents = fs4.readFileSync(current, "utf8");
+          const contents = fs5.readFileSync(current, "utf8");
           const lines = contents.split(/\r?\n/);
           for (let idx = 0; idx < lines.length && hits.length < FILE_LIMITS.MAX_SEARCH_RESULTS; idx++) {
             const line = lines[idx];
             if (line.includes(query)) {
               hits.push({
-                file: path3.relative(this.workspaceRoot, current),
+                file: path4.relative(this.workspaceRoot, current),
                 line: idx + 1,
                 text: line.trim()
               });
@@ -1027,16 +1281,16 @@ var FileActionManager = class {
   }
   async createDirectory(relativePath) {
     const dirPath = this.resolvePath(relativePath);
-    await fs4.ensureDir(dirPath);
+    await fs5.ensureDir(dirPath);
   }
   async deletePath(relativePath, description) {
     const fullPath = this.resolvePath(relativePath);
-    const exists = await fs4.pathExists(fullPath);
+    const exists = await fs5.pathExists(fullPath);
     if (!exists) {
       throw new Error(`${relativePath} does not exist.`);
     }
-    const stats = await fs4.stat(fullPath);
-    const previousContents = stats.isFile() ? await fs4.readFile(fullPath, "utf8") : "";
+    const stats = await fs5.stat(fullPath);
+    const previousContents = stats.isFile() ? await fs5.readFile(fullPath, "utf8") : "";
     if (this.previewMode) {
       this.addBatchedChange(
         relativePath,
@@ -1051,18 +1305,18 @@ var FileActionManager = class {
       absolutePath: fullPath,
       previousContents
     });
-    await fs4.remove(fullPath);
+    await fs5.remove(fullPath);
   }
   async renamePath(from, to) {
     const fromPath = this.resolvePath(from);
     const toPath = this.resolvePath(to);
-    await fs4.ensureDir(path3.dirname(toPath));
-    await fs4.move(fromPath, toPath, { overwrite: true });
+    await fs5.ensureDir(path4.dirname(toPath));
+    await fs5.move(fromPath, toPath, { overwrite: true });
   }
   async copyPath(from, to) {
     const fromPath = this.resolvePath(from);
     const toPath = this.resolvePath(to);
-    await fs4.copy(fromPath, toPath, { overwrite: true });
+    await fs5.copy(fromPath, toPath, { overwrite: true });
   }
   async replaceInFile(relativePath, searchValue, replaceValue) {
     const current = await this.readFile(relativePath);
@@ -1076,10 +1330,10 @@ var FileActionManager = class {
   }
   renderContext(hit, contextLines) {
     const filePath = this.resolvePath(hit.file);
-    if (!fs4.existsSync(filePath)) {
+    if (!fs5.existsSync(filePath)) {
       return `${hit.file}:${hit.line}`;
     }
-    const contents = fs4.readFileSync(filePath, "utf8");
+    const contents = fs5.readFileSync(filePath, "utf8");
     const lines = contents.split(/\r?\n/);
     const start = Math.max(0, hit.line - 1 - contextLines);
     const end = Math.min(lines.length, hit.line - 1 + contextLines + 1);
@@ -1495,7 +1749,10 @@ var OpenRouterClient = class {
     this.baseUrl = settings.baseUrl ?? DEFAULT_BASE_URL;
     this.defaultModel = settings.model;
     const configuredRetries = networkSettings?.maxRetries ?? DEFAULT_MAX_RETRIES;
-    this.maxRetries = Math.min(Math.max(0, configuredRetries), MAX_ALLOWED_RETRIES);
+    this.maxRetries = Math.min(
+      Math.max(0, configuredRetries),
+      MAX_ALLOWED_RETRIES
+    );
     this.retryDelay = networkSettings?.retryDelay ?? DEFAULT_RETRY_DELAY;
     this.timeout = networkSettings?.timeout ?? DEFAULT_TIMEOUT;
   }
@@ -1526,8 +1783,8 @@ var OpenRouterClient = class {
     }
     const headers = {
       "Content-Type": "application/json",
-      "HTTP-Referer": "https://github.com/autohand/cli",
-      "X-Title": "autohand-cli"
+      "HTTP-Referer": "https://github.com/autohandai/code-cli",
+      "X-Title": "autohand-code-cli"
     };
     if (this.apiKey) {
       headers.Authorization = `Bearer ${this.apiKey}`;
@@ -1544,7 +1801,12 @@ var OpenRouterClient = class {
     let lastError = null;
     for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
       try {
-        const response = await this.makeRequest(payload, headers, request.signal, payloadJson);
+        const response = await this.makeRequest(
+          payload,
+          headers,
+          request.signal,
+          payloadJson
+        );
         return response;
       } catch (error) {
         lastError = error;
@@ -1563,7 +1825,10 @@ var OpenRouterClient = class {
     let response;
     try {
       const timeoutController = new AbortController();
-      const timeoutId = setTimeout(() => timeoutController.abort(), this.timeout);
+      const timeoutId = setTimeout(
+        () => timeoutController.abort(),
+        this.timeout
+      );
       const combinedSignal = signal ? this.combineSignals(signal, timeoutController.signal) : timeoutController.signal;
       try {
         response = await fetch(`${this.baseUrl}/chat/completions`, {
@@ -1581,7 +1846,9 @@ var OpenRouterClient = class {
         throw new Error("Request cancelled.");
       }
       if (err.name === "AbortError") {
-        throw new Error("Request timed out. The AI service may be experiencing high load.");
+        throw new Error(
+          "Request timed out. The AI service may be experiencing high load."
+        );
       }
       throw new Error(
         "Unable to connect to the AI service. Please check your internet connection."
@@ -1599,7 +1866,9 @@ var OpenRouterClient = class {
       toolCalls = message.tool_calls.map((tc) => {
         const rawArgs = tc.function?.arguments;
         if (!rawArgs || rawArgs === "{}" || rawArgs === "") {
-          console.error(`[DEBUG] Tool "${tc.function?.name}" raw arguments from API: "${rawArgs}" (type: ${typeof rawArgs})`);
+          console.error(
+            `[DEBUG] Tool "${tc.function?.name}" raw arguments from API: "${rawArgs}" (type: ${typeof rawArgs})`
+          );
         }
         return {
           id: tc.id,
@@ -1797,8 +2066,8 @@ var ProviderFactory = class {
 
 // src/core/agent.ts
 import chalk13 from "chalk";
-import fs20 from "fs-extra";
-import path19 from "path";
+import fs19 from "fs-extra";
+import path18 from "path";
 import { randomUUID } from "crypto";
 import { spawnSync as spawnSync5 } from "child_process";
 import ora from "ora";
@@ -2018,12 +2287,12 @@ var MentionPreview = class {
         const dir = parts.length ? parts.join("/") + "/" : "";
         if (isSelected) {
           const highlighted = chalk2.cyan(filename);
-          const path22 = dir ? chalk2.gray(dir) : "";
-          return `${pointer} ${path22}${highlighted}`;
+          const path21 = dir ? chalk2.gray(dir) : "";
+          return `${pointer} ${path21}${highlighted}`;
         }
         const dimmedFilename = chalk2.white(filename);
-        const path21 = dir ? chalk2.gray(dir) : "";
-        return `${pointer} ${path21}${dimmedFilename}`;
+        const path20 = dir ? chalk2.gray(dir) : "";
+        return `${pointer} ${path20}${dimmedFilename}`;
       }
       const text = isSelected ? chalk2.cyan(entry) : entry;
       return `${pointer} ${text}`;
@@ -3562,7 +3831,8 @@ var SLASH_COMMANDS = [
   metadata23,
   installMetadata,
   metadata24,
-  metadata25
+  metadata25,
+  metadata26
 ];
 
 // src/core/conversationManager.ts
@@ -4676,7 +4946,7 @@ import { diffLines } from "diff";
 
 // src/ui/syntaxHighlight.ts
 import chalk5 from "chalk";
-import path4 from "path";
+import path5 from "path";
 var EXTENSION_MAP = {
   ".ts": "typescript",
   ".tsx": "typescript",
@@ -5075,11 +5345,11 @@ var BUILTIN_TYPES = {
 };
 function detectLanguage(filePath, content) {
   if (filePath) {
-    const ext = path4.extname(filePath).toLowerCase();
+    const ext = path5.extname(filePath).toLowerCase();
     if (EXTENSION_MAP[ext]) {
       return EXTENSION_MAP[ext];
     }
-    const basename3 = path4.basename(filePath).toLowerCase();
+    const basename3 = path5.basename(filePath).toLowerCase();
     if (basename3 === "dockerfile") return "dockerfile";
     if (basename3 === "makefile") return "makefile";
     if (basename3.endsWith(".d.ts")) return "typescript";
@@ -5205,14 +5475,14 @@ function highlightLine(line, language) {
 }
 
 // src/actions/dependencies.ts
-import fs5 from "fs-extra";
-import path5 from "path";
+import fs6 from "fs-extra";
+import path6 from "path";
 async function readPackageManifest(cwd) {
-  const manifestPath = path5.join(cwd, "package.json");
-  if (!await fs5.pathExists(manifestPath)) {
+  const manifestPath = path6.join(cwd, "package.json");
+  if (!await fs6.pathExists(manifestPath)) {
     return null;
   }
-  return fs5.readJson(manifestPath);
+  return fs6.readJson(manifestPath);
 }
 async function addDependency(cwd, name, version, options = {}) {
   const manifest = await readPackageManifest(cwd) ?? {};
@@ -5223,16 +5493,16 @@ async function addDependency(cwd, name, version, options = {}) {
     manifest.dependencies = manifest.dependencies ?? {};
     manifest.dependencies[name] = version;
   }
-  const manifestPath = path5.join(cwd, "package.json");
-  await fs5.writeJson(manifestPath, manifest, { spaces: 2 });
+  const manifestPath = path6.join(cwd, "package.json");
+  await fs6.writeJson(manifestPath, manifest, { spaces: 2 });
 }
 async function removeDependency(cwd, name, options = {}) {
   const manifest = await readPackageManifest(cwd) ?? {};
   const targetKey = options.dev ? "devDependencies" : "dependencies";
   if (manifest[targetKey] && manifest[targetKey][name]) {
     delete manifest[targetKey][name];
-    const manifestPath = path5.join(cwd, "package.json");
-    await fs5.writeJson(manifestPath, manifest, { spaces: 2 });
+    const manifestPath = path6.join(cwd, "package.json");
+    await fs6.writeJson(manifestPath, manifest, { spaces: 2 });
   }
 }
 
@@ -5301,16 +5571,16 @@ function runCommand(cmd, args, cwd, options = {}) {
 
 // src/actions/metadata.ts
 import crypto2 from "crypto";
-import fs6 from "fs-extra";
-import path6 from "path";
+import fs7 from "fs-extra";
+import path7 from "path";
 var ALWAYS_SKIP = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", "__pycache__", ".cache"]);
 async function listDirectoryTree(root, options = {}) {
   const depth = options.depth ?? 2;
   const maxEntries = options.maxEntries ?? 200;
   const workspaceRoot = options.workspaceRoot ?? root;
   const result = [];
-  const resolvedRoot = path6.resolve(root);
-  const resolvedWorkspace = path6.resolve(workspaceRoot);
+  const resolvedRoot = path7.resolve(root);
+  const resolvedWorkspace = path7.resolve(workspaceRoot);
   if (!resolvedRoot.startsWith(resolvedWorkspace)) {
     throw new Error(`Path ${root} is outside the workspace root.`);
   }
@@ -5321,7 +5591,7 @@ async function listDirectoryTree(root, options = {}) {
     }
     let entries;
     try {
-      entries = await fs6.readdir(current);
+      entries = await fs7.readdir(current);
     } catch (err) {
       return;
     }
@@ -5330,13 +5600,13 @@ async function listDirectoryTree(root, options = {}) {
       if (entry.startsWith(".")) {
         continue;
       }
-      const full = path6.join(current, entry);
-      const rel = path6.relative(workspaceRoot, full);
+      const full = path7.join(current, entry);
+      const rel = path7.relative(workspaceRoot, full);
       if (ALWAYS_SKIP.has(entry) || ignoreFilter.isIgnored(rel)) {
         continue;
       }
       try {
-        const stats = await fs6.stat(full);
+        const stats = await fs7.stat(full);
         result.push(`${prefix}${entry}${stats.isDirectory() ? "/" : ""}`);
         if (stats.isDirectory() && currentDepth < depth) {
           await walk(full, `${prefix}  `, currentDepth + 1);
@@ -5353,11 +5623,11 @@ async function listDirectoryTree(root, options = {}) {
   return result;
 }
 async function fileStats(root, relativePath) {
-  const fullPath = path6.join(root, relativePath);
-  if (!await fs6.pathExists(fullPath)) {
+  const fullPath = path7.join(root, relativePath);
+  if (!await fs7.pathExists(fullPath)) {
     return null;
   }
-  const stats = await fs6.stat(fullPath);
+  const stats = await fs7.stat(fullPath);
   return {
     size: stats.size,
     mtime: stats.mtime.toISOString(),
@@ -5365,13 +5635,13 @@ async function fileStats(root, relativePath) {
   };
 }
 async function checksumFile(root, relativePath, algorithm = "sha256") {
-  const fullPath = path6.join(root, relativePath);
-  const exists = await fs6.pathExists(fullPath);
+  const fullPath = path7.join(root, relativePath);
+  const exists = await fs7.pathExists(fullPath);
   if (!exists) {
     throw new Error(`${relativePath} does not exist.`);
   }
   const hash = crypto2.createHash(algorithm);
-  const stream = fs6.createReadStream(fullPath);
+  const stream = fs7.createReadStream(fullPath);
   return await new Promise((resolve, reject) => {
     stream.on("data", (chunk) => hash.update(chunk));
     stream.on("error", reject);
@@ -5381,9 +5651,9 @@ async function checksumFile(root, relativePath, algorithm = "sha256") {
 
 // src/actions/worktree.ts
 import { spawnSync as spawnSync4, spawn as spawn2 } from "child_process";
-import path7 from "path";
-import fs7 from "fs-extra";
-import os3 from "os";
+import path8 from "path";
+import fs8 from "fs-extra";
+import os4 from "os";
 var DEFAULT_TEMPLATES = [
   {
     name: "feature",
@@ -5419,7 +5689,7 @@ var DEFAULT_TEMPLATES = [
 var WorktreeManager = class {
   constructor(cwd) {
     this.repoRoot = this.findGitRoot(cwd);
-    this.repoName = path7.basename(this.repoRoot);
+    this.repoName = path8.basename(this.repoRoot);
     this.templates = [...DEFAULT_TEMPLATES];
   }
   // ============ Core Operations ============
@@ -5468,9 +5738,9 @@ var WorktreeManager = class {
     if (template) {
       worktreePath = this.resolvePath(template.pathPattern, branch);
     } else {
-      worktreePath = path7.join(path7.dirname(this.repoRoot), `${this.repoName}-${branch}`);
+      worktreePath = path8.join(path8.dirname(this.repoRoot), `${this.repoName}-${branch}`);
     }
-    await fs7.ensureDir(path7.dirname(worktreePath));
+    await fs8.ensureDir(path8.dirname(worktreePath));
     const args = ["worktree", "add"];
     if (options.newBranch) {
       args.push("-b", branch);
@@ -5511,7 +5781,7 @@ var WorktreeManager = class {
    * Remove a worktree with cleanup
    */
   async remove(worktreePath, options = {}) {
-    const absolutePath = path7.isAbsolute(worktreePath) ? worktreePath : path7.resolve(this.repoRoot, worktreePath);
+    const absolutePath = path8.isAbsolute(worktreePath) ? worktreePath : path8.resolve(this.repoRoot, worktreePath);
     const worktrees = this.list();
     const wt = worktrees.find((w) => w.path === absolutePath);
     const branchToDelete = wt?.branch;
@@ -5579,7 +5849,7 @@ var WorktreeManager = class {
   async runParallel(command, options = {}) {
     const worktrees = this.list().filter((wt) => !wt.bare);
     const filtered = options.filter ? worktrees.filter(options.filter) : worktrees;
-    const maxConcurrent = options.maxConcurrent || os3.cpus().length;
+    const maxConcurrent = options.maxConcurrent || os4.cpus().length;
     const timeout = options.timeout || 3e5;
     const results = [];
     const running = [];
@@ -5814,7 +6084,7 @@ var WorktreeManager = class {
   resolvePath(pattern, branch) {
     const timestamp = Date.now().toString();
     const sanitizedBranch = branch.replace(/[^a-zA-Z0-9-_]/g, "-");
-    return path7.resolve(
+    return path8.resolve(
       this.repoRoot,
       pattern.replace("{repo}", this.repoName).replace("{branch}", sanitizedBranch).replace("{timestamp}", timestamp)
     );
@@ -5880,20 +6150,20 @@ var WorktreeManager = class {
 };
 
 // src/core/customCommands.ts
-import fs8 from "fs-extra";
-import path8 from "path";
+import fs9 from "fs-extra";
+import path9 from "path";
 var COMMANDS_DIR = AUTOHAND_PATHS.commands;
 async function loadCustomCommand(name) {
-  const filePath = path8.join(COMMANDS_DIR, `${sanitizeName(name)}.json`);
-  if (!await fs8.pathExists(filePath)) {
+  const filePath = path9.join(COMMANDS_DIR, `${sanitizeName(name)}.json`);
+  if (!await fs9.pathExists(filePath)) {
     return null;
   }
-  return fs8.readJson(filePath);
+  return fs9.readJson(filePath);
 }
 async function saveCustomCommand(definition) {
-  await fs8.ensureDir(COMMANDS_DIR);
-  const filePath = path8.join(COMMANDS_DIR, `${sanitizeName(definition.name)}.json`);
-  await fs8.writeJson(filePath, definition, { spaces: 2 });
+  await fs9.ensureDir(COMMANDS_DIR);
+  const filePath = path9.join(COMMANDS_DIR, `${sanitizeName(definition.name)}.json`);
+  await fs9.writeJson(filePath, definition, { spaces: 2 });
 }
 function sanitizeName(name) {
   return name.replace(/[^a-z0-9-_]/gi, "_");
@@ -6198,15 +6468,15 @@ function formatPackageInfo(info) {
 }
 
 // src/core/toolsRegistry.ts
-import fs9 from "fs-extra";
-import path9 from "path";
+import fs10 from "fs-extra";
+import path10 from "path";
 var ToolsRegistry = class {
   constructor(toolsDir = AUTOHAND_PATHS.tools) {
     this.toolsDir = toolsDir;
     this.metaToolCache = /* @__PURE__ */ new Map();
   }
   async initialize() {
-    await fs9.ensureDir(this.toolsDir);
+    await fs10.ensureDir(this.toolsDir);
     await this.loadMetaToolDefinitions();
   }
   async listTools(builtIns) {
@@ -6243,8 +6513,8 @@ var ToolsRegistry = class {
       ...definition,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    const filePath = path9.join(this.toolsDir, `${definition.name}.json`);
-    await fs9.writeJson(filePath, fullDef, { spaces: 2 });
+    const filePath = path10.join(this.toolsDir, `${definition.name}.json`);
+    await fs10.writeJson(filePath, fullDef, { spaces: 2 });
     this.metaToolCache.set(definition.name, fullDef);
     return fullDef;
   }
@@ -6273,18 +6543,18 @@ var ToolsRegistry = class {
   }
   async loadMetaToolDefinitions() {
     try {
-      const exists = await fs9.pathExists(this.toolsDir);
+      const exists = await fs10.pathExists(this.toolsDir);
       if (!exists) {
         return;
       }
-      const files = await fs9.readdir(this.toolsDir);
+      const files = await fs10.readdir(this.toolsDir);
       for (const file of files) {
         if (!file.endsWith(".json")) {
           continue;
         }
-        const fullPath = path9.join(this.toolsDir, file);
+        const fullPath = path10.join(this.toolsDir, file);
         try {
-          const data = await fs9.readJson(fullPath);
+          const data = await fs10.readJson(fullPath);
           if (this.isValidMetaTool(data)) {
             this.metaToolCache.set(data.name, data);
           }
@@ -6724,8 +6994,8 @@ var ActionExecutor = class _ActionExecutor {
           throw new Error(`write_file requires a "path" argument. Received arguments: [${receivedKeys}]`);
         }
         const filePath = this.resolveWorkspacePath(action.path);
-        const fs22 = await import("fs-extra");
-        const exists = this.files.root && await fs22.pathExists(filePath);
+        const fs21 = await import("fs-extra");
+        const exists = this.files.root && await fs21.pathExists(filePath);
         const oldContent = exists ? await this.files.readFile(action.path) : "";
         const newContent = this.pickText(action.contents, action.content) ?? "";
         if (!exists) {
@@ -7128,8 +7398,8 @@ ${result.removed.map((p) => `  - ${p}`).join("\n")}`;
         const lines = [chalk6.cyan("\u{1F504} Worktree Sync Results:"), ""];
         if (result.synced.length > 0) {
           lines.push(chalk6.green(`Synced (${result.synced.length}):`));
-          for (const path21 of result.synced) {
-            lines.push(`  \u2713 ${path21}`);
+          for (const path20 of result.synced) {
+            lines.push(`  \u2713 ${path20}`);
           }
           lines.push("");
         }
@@ -8098,24 +8368,24 @@ var SlashCommandHandler = class {
     try {
       switch (command) {
         case "/model": {
-          const { model } = await import("./model-HKEFSH5E.js");
+          const { model } = await import("./model-U3BWIWVH.js");
           return model(this.ctx);
         }
         case "/init": {
-          const { init } = await import("./init-DML7AOII.js");
+          const { init } = await import("./init-WW4RITLV.js");
           return init(this.ctx);
         }
         case "/quit": {
-          const { quit } = await import("./quit-RSYIERO5.js");
+          const { quit } = await import("./quit-NIDVPHNL.js");
           return quit();
         }
         case "/help":
         case "/?": {
-          const { help } = await import("./help-PKC6QCNG.js");
+          const { help } = await import("./help-MU553D6W.js");
           return help();
         }
         case "/agents": {
-          const { handler } = await import("./agents-B33IAATH.js");
+          const { handler } = await import("./agents-E4NEH2PN.js");
           const output = await handler();
           if (output) {
             console.log(output);
@@ -8124,27 +8394,27 @@ var SlashCommandHandler = class {
         }
         case "/agents new":
         case "/agents-new": {
-          const { createAgent } = await import("./agents-new-KTXJFC5E.js");
+          const { createAgent } = await import("./agents-new-W6HMQ7V5.js");
           return createAgent(this.ctx);
         }
         case "/feedback": {
-          const { feedback } = await import("./feedback-PZ2PINDU.js");
+          const { feedback } = await import("./feedback-IZKDNGHP.js");
           return feedback(this.ctx);
         }
         case "/resume": {
-          const { resume } = await import("./resume-2NERFSTD.js");
+          const { resume } = await import("./resume-ZZ2D2NMB.js");
           return resume({ sessionManager: this.ctx.sessionManager, args });
         }
         case "/sessions": {
-          const { sessions } = await import("./sessions-4KXIT76T.js");
+          const { sessions } = await import("./sessions-ERKBJ7MC.js");
           return sessions({ sessionManager: this.ctx.sessionManager, args });
         }
         case "/session": {
-          const { session } = await import("./session-H5QWKE5E.js");
+          const { session } = await import("./session-76F55XKA.js");
           return session({ sessionManager: this.ctx.sessionManager });
         }
         case "/undo": {
-          const { undo } = await import("./undo-7QJBXARS.js");
+          const { undo } = await import("./undo-3UU5LWQS.js");
           return undo({
             workspaceRoot: this.ctx.workspaceRoot,
             undoFileMutation: this.ctx.undoFileMutation ?? (async () => {
@@ -8154,7 +8424,7 @@ var SlashCommandHandler = class {
           });
         }
         case "/new": {
-          const { newConversation } = await import("./new-EEZC4XXV.js");
+          const { newConversation } = await import("./new-PCOF6OLV.js");
           return newConversation({
             resetConversation: this.ctx.resetConversation,
             sessionManager: this.ctx.sessionManager,
@@ -8163,26 +8433,26 @@ var SlashCommandHandler = class {
           });
         }
         case "/memory": {
-          const { memory } = await import("./memory-4GSP7NKV.js");
+          const { memory } = await import("./memory-2SGSO4MW.js");
           return memory({ memoryManager: this.ctx.memoryManager });
         }
         case "/formatters": {
-          const { execute } = await import("./formatters-UG6VZJJ5.js");
+          const { execute } = await import("./formatters-JJK6RS55.js");
           await execute();
           return null;
         }
         case "/lint": {
-          const { execute } = await import("./lint-TA2ZHVLM.js");
+          const { execute } = await import("./lint-L2TD6NY6.js");
           await execute();
           return null;
         }
         case "/completion": {
-          const { execute } = await import("./completion-Y42FKDT3.js");
+          const { execute } = await import("./completion-2XTEWNMC.js");
           await execute(args.join(" "));
           return null;
         }
         case "/export": {
-          const { execute } = await import("./export-WJ5P6E5Z.js");
+          const { execute } = await import("./export-LNPP3XXH.js");
           await execute(args.join(" "), {
             sessionManager: this.ctx.sessionManager,
             currentSession: this.ctx.currentSession,
@@ -8191,30 +8461,30 @@ var SlashCommandHandler = class {
           return null;
         }
         case "/status": {
-          const { status } = await import("./status-KC56ITDB.js");
+          const { status } = await import("./status-VJ6FOSRI.js");
           return status(this.ctx);
         }
         case "/login": {
-          const { login } = await import("./login-BZ7J4Z4M.js");
+          const { login } = await import("./login-LH62FYMH.js");
           return login({ config: this.ctx.config });
         }
         case "/logout": {
-          const { logout } = await import("./logout-BZKEMNHB.js");
+          const { logout } = await import("./logout-KPHUXO23.js");
           return logout({ config: this.ctx.config });
         }
         case "/permissions": {
-          const { permissions } = await import("./permissions-5MTH22EF.js");
+          const { permissions } = await import("./permissions-5W5JOVM7.js");
           return permissions({ permissionManager: this.ctx.permissionManager });
         }
         case "/hooks": {
-          const { hooks } = await import("./hooks-5NY5K4L3.js");
+          const { hooks } = await import("./hooks-4N5VRVOF.js");
           if (!this.ctx.hookManager) {
             return "Hook manager not available.";
           }
           return hooks({ hookManager: this.ctx.hookManager });
         }
         case "/skills": {
-          const { skills } = await import("./skills-CRFOVWEQ.js");
+          const { skills } = await import("./skills-R25OBHE5.js");
           if (!this.ctx.skillsRegistry) {
             return "Skills registry not available.";
           }
@@ -8224,7 +8494,7 @@ var SlashCommandHandler = class {
           }, args);
         }
         case "/skills install": {
-          const { skillsInstall } = await import("./skills-install-RMPXN6RK.js");
+          const { skillsInstall } = await import("./skills-install-GNTBBL46.js");
           if (!this.ctx.skillsRegistry) {
             return "Skills registry not available.";
           }
@@ -8236,7 +8506,7 @@ var SlashCommandHandler = class {
         }
         case "/skills new":
         case "/skills-new": {
-          const { createSkill } = await import("./skills-new-S2YPO635.js");
+          const { createSkill } = await import("./skills-new-L36LQXIE.js");
           if (!this.ctx.skillsRegistry) {
             return "Skills registry not available.";
           }
@@ -8247,13 +8517,20 @@ var SlashCommandHandler = class {
           });
         }
         case "/theme": {
-          const { theme } = await import("./theme-JAMJSCKR.js");
+          const { theme } = await import("./theme-ZXGSJBZI.js");
           if (!this.ctx.config) {
             console.log(chalk7.yellow("Config not available for theme selection."));
             return null;
           }
           return theme({ config: this.ctx.config });
         }
+        case "/automode": {
+          const { automode } = await import("./automode-XCNP6HP4.js");
+          return automode({
+            automodeManager: this.ctx.automodeManager,
+            workspaceRoot: this.ctx.workspaceRoot
+          }, args);
+        }
         default:
           this.printUnsupported(command);
           return null;
@@ -8277,196 +8554,10 @@ var SlashCommandHandler = class {
   }
 };
 
-// src/session/SessionManager.ts
-import fs10 from "fs-extra";
-import path10 from "path";
-import crypto3 from "crypto";
-var SessionManager = class {
-  constructor(baseDir) {
-    this.currentSession = null;
-    this.index = null;
-    this.sessionsDir = baseDir ?? AUTOHAND_PATHS.sessions;
-  }
-  async initialize() {
-    await fs10.ensureDir(this.sessionsDir);
-    await this.loadIndex();
-  }
-  async createSession(projectPath, model) {
-    const sessionId = this.generateSessionId();
-    const sessionDir = path10.join(this.sessionsDir, sessionId);
-    await fs10.ensureDir(sessionDir);
-    const metadata26 = {
-      sessionId,
-      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      lastActiveAt: (/* @__PURE__ */ new Date()).toISOString(),
-      projectPath: path10.resolve(projectPath),
-      projectName: path10.basename(projectPath),
-      model,
-      messageCount: 0,
-      status: "active"
-    };
-    const session = new Session(sessionDir, metadata26);
-    await session.save();
-    this.currentSession = session;
-    await this.addToIndex(session.metadata);
-    return session;
-  }
-  async loadSession(sessionId) {
-    const sessionDir = path10.join(this.sessionsDir, sessionId);
-    if (!await fs10.pathExists(sessionDir)) {
-      throw new Error(`Session not found: ${sessionId}`);
-    }
-    const metadataPath = path10.join(sessionDir, "metadata.json");
-    const metadata26 = await fs10.readJson(metadataPath);
-    const session = new Session(sessionDir, metadata26);
-    await session.load();
-    this.currentSession = session;
-    return session;
-  }
-  async listSessions(filter) {
-    await this.loadIndex();
-    if (!this.index) return [];
-    let sessions = this.index.sessions;
-    if (filter?.project) {
-      const projectPath = path10.resolve(filter.project);
-      const sessionIds = this.index.byProject[projectPath] || [];
-      sessions = sessions.filter((s) => sessionIds.includes(s.id));
-    }
-    if (filter?.since) {
-      sessions = sessions.filter((s) => new Date(s.createdAt) >= filter.since);
-    }
-    const fullMetadata = [];
-    for (const s of sessions) {
-      const sessionDir = path10.join(this.sessionsDir, s.id);
-      const metadataPath = path10.join(sessionDir, "metadata.json");
-      if (await fs10.pathExists(metadataPath)) {
-        const metadata26 = await fs10.readJson(metadataPath);
-        fullMetadata.push(metadata26);
-      }
-    }
-    return fullMetadata.sort(
-      (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
-    );
-  }
-  async getLastSession(projectPath) {
-    const sessions = await this.listSessions(projectPath ? { project: projectPath } : void 0);
-    return sessions[0] || null;
-  }
-  async closeSession(summary) {
-    if (!this.currentSession) return;
-    this.currentSession.metadata.closedAt = (/* @__PURE__ */ new Date()).toISOString();
-    this.currentSession.metadata.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
-    this.currentSession.metadata.status = "completed";
-    if (summary) {
-      this.currentSession.metadata.summary = summary;
-    }
-    await this.currentSession.save();
-    await this.updateIndex(this.currentSession.metadata);
-    this.currentSession = null;
-  }
-  getCurrentSession() {
-    return this.currentSession;
-  }
-  generateSessionId() {
-    const timestamp = Date.now();
-    const uuid = crypto3.randomUUID();
-    return `${uuid}-${timestamp}`;
-  }
-  async loadIndex() {
-    const indexPath = path10.join(this.sessionsDir, "index.json");
-    if (await fs10.pathExists(indexPath)) {
-      this.index = await fs10.readJson(indexPath);
-    } else {
-      this.index = { sessions: [], byProject: {} };
-    }
-  }
-  async saveIndex() {
-    const indexPath = path10.join(this.sessionsDir, "index.json");
-    await fs10.writeJson(indexPath, this.index, { spaces: 2 });
-  }
-  async addToIndex(metadata26) {
-    if (!this.index) await this.loadIndex();
-    if (!this.index) return;
-    this.index.sessions.push({
-      id: metadata26.sessionId,
-      projectPath: metadata26.projectPath,
-      createdAt: metadata26.createdAt,
-      summary: metadata26.summary
-    });
-    if (!this.index.byProject[metadata26.projectPath]) {
-      this.index.byProject[metadata26.projectPath] = [];
-    }
-    this.index.byProject[metadata26.projectPath].push(metadata26.sessionId);
-    await this.saveIndex();
-  }
-  async updateIndex(metadata26) {
-    if (!this.index) return;
-    const session = this.index.sessions.find((s) => s.id === metadata26.sessionId);
-    if (session) {
-      session.summary = metadata26.summary;
-    }
-    await this.saveIndex();
-  }
-};
-var Session = class {
-  constructor(sessionDir, metadata26) {
-    this.messages = [];
-    this.state = null;
-    this.sessionDir = sessionDir;
-    this.metadata = metadata26;
-  }
-  async append(message) {
-    this.messages.push(message);
-    this.metadata.messageCount = this.messages.length;
-    this.metadata.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
-    const conversationPath = path10.join(this.sessionDir, "conversation.jsonl");
-    await fs10.appendFile(conversationPath, JSON.stringify(message) + "\n");
-    await this.save();
-  }
-  async appendTransient(message) {
-    const conversationPath = path10.join(this.sessionDir, "conversation.jsonl");
-    await fs10.appendFile(conversationPath, JSON.stringify(message) + "\n");
-  }
-  async updateState(state) {
-    this.state = state;
-    const statePath = path10.join(this.sessionDir, "state.json");
-    await fs10.writeJson(statePath, state, { spaces: 2 });
-  }
-  async save() {
-    const metadataPath = path10.join(this.sessionDir, "metadata.json");
-    await fs10.writeJson(metadataPath, this.metadata, { spaces: 2 });
-  }
-  async load() {
-    const conversationPath = path10.join(this.sessionDir, "conversation.jsonl");
-    if (await fs10.pathExists(conversationPath)) {
-      const content = await fs10.readFile(conversationPath, "utf-8");
-      this.messages = content.trim().split("\n").filter((line) => line).map((line) => JSON.parse(line));
-    }
-    const statePath = path10.join(this.sessionDir, "state.json");
-    if (await fs10.pathExists(statePath)) {
-      this.state = await fs10.readJson(statePath);
-    }
-  }
-  getMessages() {
-    return this.messages;
-  }
-  getState() {
-    return this.state;
-  }
-  async close(summary) {
-    this.metadata.closedAt = (/* @__PURE__ */ new Date()).toISOString();
-    this.metadata.status = "completed";
-    if (summary) {
-      this.metadata.summary = summary;
-    }
-    await this.save();
-  }
-};
-
 // src/session/ProjectManager.ts
 import fs11 from "fs-extra";
 import path11 from "path";
-import crypto4 from "crypto";
+import crypto3 from "crypto";
 var ProjectManager = class {
   constructor(baseDir) {
     this.projectCache = /* @__PURE__ */ new Map();
@@ -8658,7 +8749,7 @@ var ProjectManager = class {
     return candidates.filter((c) => tags.some((t) => t.toLowerCase().includes(c)));
   }
   hashPath(projectPath) {
-    return crypto4.createHash("sha256").update(path11.resolve(projectPath)).digest("hex").slice(0, 8);
+    return crypto3.createHash("sha256").update(path11.resolve(projectPath)).digest("hex").slice(0, 8);
   }
 };
 
@@ -9022,7 +9113,7 @@ ${result}`;
 
 // src/core/errorLogger.ts
 import fs12 from "fs-extra";
-import os4 from "os";
+import os5 from "os";
 import path12 from "path";
 var ErrorLogger = class {
   constructor(cliVersion, logDir) {
@@ -9055,13 +9146,13 @@ var ErrorLogger = class {
     }
   }
   getSystemInfo() {
-    const cpus = os4.cpus();
-    const totalMem = os4.totalmem();
-    const freeMem = os4.freemem();
+    const cpus = os5.cpus();
+    const totalMem = os5.totalmem();
+    const freeMem = os5.freemem();
     return {
-      platform: os4.platform(),
-      arch: os4.arch(),
-      release: os4.release(),
+      platform: os5.platform(),
+      arch: os5.arch(),
+      release: os5.release(),
       nodeVersion: process.version,
       bunVersion: process.versions.bun,
       memory: {
@@ -9073,8 +9164,8 @@ var ErrorLogger = class {
         model: cpus[0]?.model || "Unknown",
         cores: cpus.length
       },
-      hostname: os4.hostname(),
-      username: os4.userInfo().username
+      hostname: os5.hostname(),
+      username: os5.userInfo().username
     };
   }
   async getRecentErrors(count = 10) {
@@ -9100,309 +9191,76 @@ var ErrorLogger = class {
   }
 };
 
-// src/memory/MemoryManager.ts
+// src/feedback/FeedbackManager.ts
+import fs14 from "fs-extra";
+import path14 from "path";
+import chalk10 from "chalk";
+import Enquirer from "enquirer";
+
+// src/feedback/FeedbackApiClient.ts
 import fs13 from "fs-extra";
 import path13 from "path";
-import crypto5 from "crypto";
-var SIMILARITY_THRESHOLD = 0.6;
-var MemoryManager = class {
-  constructor(workspaceRoot) {
-    this.projectMemoryDir = null;
-    this.userMemoryDir = AUTOHAND_PATHS.memory;
-    if (workspaceRoot) {
-      this.projectMemoryDir = path13.join(workspaceRoot, PROJECT_DIR_NAME, "memory");
-    }
-  }
-  setWorkspace(workspaceRoot) {
-    this.projectMemoryDir = path13.join(workspaceRoot, PROJECT_DIR_NAME, "memory");
-  }
-  async initialize() {
-    await fs13.ensureDir(this.userMemoryDir);
-    if (this.projectMemoryDir) {
-      await fs13.ensureDir(this.projectMemoryDir);
-    }
+import os6 from "os";
+var DEFAULT_CONFIG = {
+  baseUrl: "https://api.autohand.ai",
+  timeout: 5e3,
+  maxRetries: 3,
+  offlineQueue: true,
+  cliVersion: "0.1.0",
+  companySecret: ""
+};
+var FeedbackApiClient = class {
+  constructor(configOverrides) {
+    this.deviceId = null;
+    this.config = { ...DEFAULT_CONFIG, ...configOverrides };
+    const dataDir = AUTOHAND_PATHS.feedback;
+    this.queuePath = path13.join(dataDir, "queue.json");
+    this.deviceIdPath = path13.join(dataDir, ".device-id");
   }
-  getMemoryDir(level) {
-    if (level === "project") {
-      if (!this.projectMemoryDir) {
-        throw new Error("Project memory directory not set. Use setWorkspace() first.");
+  // ============ Device ID ============
+  /**
+   * Get or create anonymous device identifier
+   * Used for deduplication and analytics, not tracking
+   */
+  async getDeviceId() {
+    if (this.deviceId) return this.deviceId;
+    try {
+      if (await fs13.pathExists(this.deviceIdPath)) {
+        this.deviceId = (await fs13.readFile(this.deviceIdPath, "utf8")).trim();
+        return this.deviceId;
       }
-      return this.projectMemoryDir;
-    }
-    return this.userMemoryDir;
-  }
-  async store(content, level, tags, source) {
-    const dir = this.getMemoryDir(level);
-    await fs13.ensureDir(dir);
-    const similar = await this.findSimilar(content, level);
-    if (similar && similar.score >= SIMILARITY_THRESHOLD) {
-      return this.updateMemory(similar.entry.id, content, level, tags);
+    } catch {
     }
-    const id = this.generateId();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const entry = {
-      id,
-      content,
-      createdAt: now,
-      updatedAt: now,
-      tags,
-      source
-    };
-    const entryPath = path13.join(dir, `${id}.json`);
-    await fs13.writeJson(entryPath, entry, { spaces: 2 });
-    await this.updateIndex(level, entry);
-    return entry;
-  }
-  async updateMemory(id, content, level, tags) {
-    const dir = this.getMemoryDir(level);
-    const entryPath = path13.join(dir, `${id}.json`);
-    if (!await fs13.pathExists(entryPath)) {
-      throw new Error(`Memory entry not found: ${id}`);
-    }
-    const existing = await fs13.readJson(entryPath);
-    const updated = {
-      ...existing,
-      content,
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      tags: tags ?? existing.tags
-    };
-    await fs13.writeJson(entryPath, updated, { spaces: 2 });
-    await this.updateIndex(level, updated);
-    return updated;
-  }
-  async get(id, level) {
-    const dir = this.getMemoryDir(level);
-    const entryPath = path13.join(dir, `${id}.json`);
-    if (!await fs13.pathExists(entryPath)) {
-      return null;
+    this.deviceId = `anon_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+    try {
+      await fs13.ensureDir(path13.dirname(this.deviceIdPath));
+      await fs13.writeFile(this.deviceIdPath, this.deviceId);
+    } catch {
     }
-    return fs13.readJson(entryPath);
+    return this.deviceId;
   }
-  async list(level) {
-    const dir = this.getMemoryDir(level);
-    if (!await fs13.pathExists(dir)) {
-      return [];
-    }
-    const files = await fs13.readdir(dir);
-    const entries = [];
-    for (const file of files) {
-      if (file.endsWith(".json") && file !== "index.json") {
-        const entryPath = path13.join(dir, file);
-        const entry = await fs13.readJson(entryPath);
-        entries.push(entry);
+  // ============ Submission ============
+  /**
+   * Submit feedback to the API
+   * Automatically queues for retry if offline
+   */
+  async submit(feedback) {
+    const submission = await this.enrichFeedback(feedback);
+    try {
+      const response = await this.sendToApi(submission);
+      if (response.success) {
+        this.flushQueue().catch(() => {
+        });
       }
-    }
-    return entries.sort(
-      (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
-    );
-  }
-  async listAll() {
-    const user = await this.list("user");
-    let project = [];
-    if (this.projectMemoryDir) {
-      try {
-        project = await this.list("project");
-      } catch {
-      }
-    }
-    return { project, user };
-  }
-  async delete(id, level) {
-    const dir = this.getMemoryDir(level);
-    const entryPath = path13.join(dir, `${id}.json`);
-    if (await fs13.pathExists(entryPath)) {
-      await fs13.remove(entryPath);
-      await this.removeFromIndex(level, id);
-    }
-  }
-  async findSimilar(content, level) {
-    const entries = await this.list(level);
-    let bestMatch = null;
-    for (const entry of entries) {
-      const score = this.calculateSimilarity(content, entry.content);
-      if (!bestMatch || score > bestMatch.score) {
-        bestMatch = { entry, score };
-      }
-    }
-    return bestMatch;
-  }
-  async search(query, level) {
-    const levels = level ? [level] : ["project", "user"];
-    const results = [];
-    const queryLower = query.toLowerCase();
-    for (const lvl of levels) {
-      try {
-        const entries = await this.list(lvl);
-        for (const entry of entries) {
-          if (entry.content.toLowerCase().includes(queryLower) || entry.tags?.some((t) => t.toLowerCase().includes(queryLower))) {
-            results.push(entry);
-          }
-        }
-      } catch {
-      }
-    }
-    return results;
-  }
-  async recall(query, level) {
-    const levels = level ? [level] : ["user", "project"];
-    const results = [];
-    for (const lvl of levels) {
-      try {
-        const entries = await this.list(lvl);
-        for (const entry of entries) {
-          if (!query || entry.content.toLowerCase().includes(query.toLowerCase())) {
-            results.push({ content: entry.content, level: lvl });
-          }
-        }
-      } catch {
-      }
-    }
-    return results;
-  }
-  /**
-   * Get memories formatted for LLM context injection
-   */
-  async getContextMemories() {
-    const { project, user } = await this.listAll();
-    const parts = [];
-    if (project.length > 0) {
-      parts.push("## Project Memories");
-      for (const entry of project.slice(0, 10)) {
-        parts.push(`- ${entry.content}`);
-      }
-    }
-    if (user.length > 0) {
-      parts.push("## User Preferences");
-      for (const entry of user.slice(0, 10)) {
-        parts.push(`- ${entry.content}`);
-      }
-    }
-    return parts.join("\n");
-  }
-  calculateSimilarity(a, b) {
-    const wordsA = this.tokenize(a);
-    const wordsB = this.tokenize(b);
-    if (wordsA.size === 0 || wordsB.size === 0) {
-      return 0;
-    }
-    const intersection = new Set([...wordsA].filter((x) => wordsB.has(x)));
-    const union = /* @__PURE__ */ new Set([...wordsA, ...wordsB]);
-    return intersection.size / union.size;
-  }
-  tokenize(text) {
-    return new Set(
-      text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 2)
-    );
-  }
-  generateId() {
-    return crypto5.randomUUID().split("-")[0];
-  }
-  async updateIndex(level, entry) {
-    const dir = this.getMemoryDir(level);
-    const indexPath = path13.join(dir, "index.json");
-    let index;
-    if (await fs13.pathExists(indexPath)) {
-      index = await fs13.readJson(indexPath);
-    } else {
-      index = { version: 1, entries: [] };
-    }
-    const existingIdx = index.entries.findIndex((e) => e.id === entry.id);
-    const indexEntry = {
-      id: entry.id,
-      preview: entry.content.slice(0, 100),
-      createdAt: entry.createdAt,
-      updatedAt: entry.updatedAt,
-      tags: entry.tags
-    };
-    if (existingIdx >= 0) {
-      index.entries[existingIdx] = indexEntry;
-    } else {
-      index.entries.push(indexEntry);
-    }
-    await fs13.writeJson(indexPath, index, { spaces: 2 });
-  }
-  async removeFromIndex(level, id) {
-    const dir = this.getMemoryDir(level);
-    const indexPath = path13.join(dir, "index.json");
-    if (!await fs13.pathExists(indexPath)) {
-      return;
-    }
-    const index = await fs13.readJson(indexPath);
-    index.entries = index.entries.filter((e) => e.id !== id);
-    await fs13.writeJson(indexPath, index, { spaces: 2 });
-  }
-};
-
-// src/feedback/FeedbackManager.ts
-import fs15 from "fs-extra";
-import path15 from "path";
-import chalk10 from "chalk";
-import Enquirer from "enquirer";
-
-// src/feedback/FeedbackApiClient.ts
-import fs14 from "fs-extra";
-import path14 from "path";
-import os5 from "os";
-var DEFAULT_CONFIG = {
-  baseUrl: "https://api.autohand.ai",
-  timeout: 5e3,
-  maxRetries: 3,
-  offlineQueue: true,
-  cliVersion: "0.1.0",
-  companySecret: ""
-};
-var FeedbackApiClient = class {
-  constructor(configOverrides) {
-    this.deviceId = null;
-    this.config = { ...DEFAULT_CONFIG, ...configOverrides };
-    const dataDir = AUTOHAND_PATHS.feedback;
-    this.queuePath = path14.join(dataDir, "queue.json");
-    this.deviceIdPath = path14.join(dataDir, ".device-id");
-  }
-  // ============ Device ID ============
-  /**
-   * Get or create anonymous device identifier
-   * Used for deduplication and analytics, not tracking
-   */
-  async getDeviceId() {
-    if (this.deviceId) return this.deviceId;
-    try {
-      if (await fs14.pathExists(this.deviceIdPath)) {
-        this.deviceId = (await fs14.readFile(this.deviceIdPath, "utf8")).trim();
-        return this.deviceId;
-      }
-    } catch {
-    }
-    this.deviceId = `anon_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
-    try {
-      await fs14.ensureDir(path14.dirname(this.deviceIdPath));
-      await fs14.writeFile(this.deviceIdPath, this.deviceId);
-    } catch {
-    }
-    return this.deviceId;
-  }
-  // ============ Submission ============
-  /**
-   * Submit feedback to the API
-   * Automatically queues for retry if offline
-   */
-  async submit(feedback) {
-    const submission = await this.enrichFeedback(feedback);
-    try {
-      const response = await this.sendToApi(submission);
-      if (response.success) {
-        this.flushQueue().catch(() => {
-        });
-      }
-      return response;
-    } catch (error) {
-      if (this.config.offlineQueue) {
-        await this.addToQueue(submission);
-        return {
-          success: true,
-          // Queued successfully
-          id: `queued_${Date.now()}`
-        };
+      return response;
+    } catch (error) {
+      if (this.config.offlineQueue) {
+        await this.addToQueue(submission);
+        return {
+          success: true,
+          // Queued successfully
+          id: `queued_${Date.now()}`
+        };
       }
       return {
         success: false,
@@ -9419,7 +9277,7 @@ var FeedbackApiClient = class {
       deviceId: await this.getDeviceId(),
       cliVersion: this.config.cliVersion,
       platform: process.platform,
-      osVersion: os5.release(),
+      osVersion: os6.release(),
       nodeVersion: process.version
     };
   }
@@ -9463,8 +9321,8 @@ var FeedbackApiClient = class {
   async addToQueue(submission) {
     try {
       let queue = [];
-      if (await fs14.pathExists(this.queuePath)) {
-        queue = await fs14.readJson(this.queuePath);
+      if (await fs13.pathExists(this.queuePath)) {
+        queue = await fs13.readJson(this.queuePath);
       }
       queue.push({
         feedback: submission,
@@ -9475,8 +9333,8 @@ var FeedbackApiClient = class {
       if (queue.length > 50) {
         queue = queue.slice(-50);
       }
-      await fs14.ensureDir(path14.dirname(this.queuePath));
-      await fs14.writeJson(this.queuePath, queue, { spaces: 2 });
+      await fs13.ensureDir(path13.dirname(this.queuePath));
+      await fs13.writeJson(this.queuePath, queue, { spaces: 2 });
     } catch {
     }
   }
@@ -9487,10 +9345,10 @@ var FeedbackApiClient = class {
     let sent = 0;
     let failed = 0;
     try {
-      if (!await fs14.pathExists(this.queuePath)) {
+      if (!await fs13.pathExists(this.queuePath)) {
         return { sent, failed };
       }
-      const queue = await fs14.readJson(this.queuePath);
+      const queue = await fs13.readJson(this.queuePath);
       const remaining = [];
       for (const item of queue) {
         if (item.attempts >= this.config.maxRetries) {
@@ -9515,9 +9373,9 @@ var FeedbackApiClient = class {
         }
       }
       if (remaining.length > 0) {
-        await fs14.writeJson(this.queuePath, remaining, { spaces: 2 });
+        await fs13.writeJson(this.queuePath, remaining, { spaces: 2 });
       } else {
-        await fs14.remove(this.queuePath);
+        await fs13.remove(this.queuePath);
       }
     } catch {
     }
@@ -9528,10 +9386,10 @@ var FeedbackApiClient = class {
    */
   async getQueueStatus() {
     try {
-      if (!await fs14.pathExists(this.queuePath)) {
+      if (!await fs13.pathExists(this.queuePath)) {
         return { pending: 0, oldestItem: null };
       }
-      const queue = await fs14.readJson(this.queuePath);
+      const queue = await fs13.readJson(this.queuePath);
       return {
         pending: queue.length,
         oldestItem: queue[0]?.lastAttempt || null
@@ -9597,8 +9455,8 @@ var FeedbackManager = class {
     this.sessionInteractions = 0;
     this.hasPromptedThisSession = false;
     this.stateDir = AUTOHAND_PATHS.feedback;
-    this.statePath = path15.join(this.stateDir, "state.json");
-    this.responsesPath = path15.join(this.stateDir, "responses.json");
+    this.statePath = path14.join(this.stateDir, "state.json");
+    this.responsesPath = path14.join(this.stateDir, "responses.json");
     this.config = { ...DEFAULT_CONFIG2, ...configOverrides };
     this.state = this.loadState();
     this.sessionStartTime = Date.now();
@@ -9610,8 +9468,8 @@ var FeedbackManager = class {
   // ============ State Management ============
   loadState() {
     try {
-      if (fs15.existsSync(this.statePath)) {
-        return fs15.readJsonSync(this.statePath);
+      if (fs14.existsSync(this.statePath)) {
+        return fs14.readJsonSync(this.statePath);
       }
     } catch {
     }
@@ -9628,20 +9486,20 @@ var FeedbackManager = class {
   }
   saveState() {
     try {
-      fs15.ensureDirSync(this.stateDir);
-      fs15.writeJsonSync(this.statePath, this.state, { spaces: 2 });
+      fs14.ensureDirSync(this.stateDir);
+      fs14.writeJsonSync(this.statePath, this.state, { spaces: 2 });
     } catch {
     }
   }
   async saveFeedbackResponse(response) {
     try {
-      fs15.ensureDirSync(this.stateDir);
+      fs14.ensureDirSync(this.stateDir);
       let responses = [];
-      if (fs15.existsSync(this.responsesPath)) {
-        responses = fs15.readJsonSync(this.responsesPath);
+      if (fs14.existsSync(this.responsesPath)) {
+        responses = fs14.readJsonSync(this.responsesPath);
       }
       responses.push(response);
-      fs15.writeJsonSync(this.responsesPath, responses, { spaces: 2 });
+      fs14.writeJsonSync(this.responsesPath, responses, { spaces: 2 });
     } catch {
     }
     if (this.config.sendToApi) {
@@ -9907,8 +9765,8 @@ var FeedbackManager = class {
   /** Export all feedback responses */
   async exportResponses() {
     try {
-      if (fs15.existsSync(this.responsesPath)) {
-        return fs15.readJsonSync(this.responsesPath);
+      if (fs14.existsSync(this.responsesPath)) {
+        return fs14.readJsonSync(this.responsesPath);
       }
     } catch {
     }
@@ -9917,12 +9775,12 @@ var FeedbackManager = class {
 };
 
 // src/telemetry/TelemetryManager.ts
-import os6 from "os";
+import os7 from "os";
 
 // src/telemetry/TelemetryClient.ts
-import fs16 from "fs-extra";
-import path16 from "path";
-import crypto6 from "crypto";
+import fs15 from "fs-extra";
+import path15 from "path";
+import crypto4 from "crypto";
 var TELEMETRY_DIR = AUTOHAND_PATHS.telemetry;
 var QUEUE_FILE = AUTOHAND_FILES.telemetryQueue;
 var DEVICE_ID_FILE = AUTOHAND_FILES.deviceId;
@@ -9954,15 +9812,15 @@ var TelemetryClient = class {
    */
   getOrCreateDeviceId() {
     try {
-      fs16.ensureDirSync(path16.dirname(DEVICE_ID_FILE));
-      if (fs16.existsSync(DEVICE_ID_FILE)) {
-        return fs16.readFileSync(DEVICE_ID_FILE, "utf8").trim();
+      fs15.ensureDirSync(path15.dirname(DEVICE_ID_FILE));
+      if (fs15.existsSync(DEVICE_ID_FILE)) {
+        return fs15.readFileSync(DEVICE_ID_FILE, "utf8").trim();
       }
-      const id = crypto6.randomUUID();
-      fs16.writeFileSync(DEVICE_ID_FILE, id);
+      const id = crypto4.randomUUID();
+      fs15.writeFileSync(DEVICE_ID_FILE, id);
       return id;
     } catch {
-      return crypto6.randomUUID();
+      return crypto4.randomUUID();
     }
   }
   /**
@@ -9970,9 +9828,9 @@ var TelemetryClient = class {
    */
   loadQueue() {
     try {
-      fs16.ensureDirSync(TELEMETRY_DIR);
-      if (fs16.existsSync(QUEUE_FILE)) {
-        const data = fs16.readFileSync(QUEUE_FILE, "utf8");
+      fs15.ensureDirSync(TELEMETRY_DIR);
+      if (fs15.existsSync(QUEUE_FILE)) {
+        const data = fs15.readFileSync(QUEUE_FILE, "utf8");
         this.queue = JSON.parse(data);
       }
     } catch {
@@ -9984,8 +9842,8 @@ var TelemetryClient = class {
    */
   saveQueue() {
     try {
-      fs16.ensureDirSync(TELEMETRY_DIR);
-      fs16.writeFileSync(QUEUE_FILE, JSON.stringify(this.queue, null, 2));
+      fs15.ensureDirSync(TELEMETRY_DIR);
+      fs15.writeFileSync(QUEUE_FILE, JSON.stringify(this.queue, null, 2));
     } catch {
     }
   }
@@ -10040,7 +9898,7 @@ var TelemetryClient = class {
     if (!this.config.enabled) return;
     const fullEvent = {
       ...event,
-      id: crypto6.randomUUID(),
+      id: crypto4.randomUUID(),
       deviceId: this.deviceId,
       clientType: this.config.clientType,
       clientVersion: this.config.clientVersion,
@@ -10135,16 +9993,16 @@ var TelemetryClient = class {
     const online = await this.isOnline();
     if (!online) {
       try {
-        const syncQueueFile = path16.join(TELEMETRY_DIR, "session-sync-queue.json");
+        const syncQueueFile = path15.join(TELEMETRY_DIR, "session-sync-queue.json");
         let syncQueue = [];
-        if (fs16.existsSync(syncQueueFile)) {
-          syncQueue = JSON.parse(fs16.readFileSync(syncQueueFile, "utf8"));
+        if (fs15.existsSync(syncQueueFile)) {
+          syncQueue = JSON.parse(fs15.readFileSync(syncQueueFile, "utf8"));
         }
         syncQueue.push(sessionData);
         if (syncQueue.length > 10) {
           syncQueue = syncQueue.slice(-10);
         }
-        fs16.writeFileSync(syncQueueFile, JSON.stringify(syncQueue, null, 2));
+        fs15.writeFileSync(syncQueueFile, JSON.stringify(syncQueue, null, 2));
         return { success: false, error: "Offline - queued for sync" };
       } catch {
         return { success: false, error: "Failed to queue session" };
@@ -10179,12 +10037,12 @@ var TelemetryClient = class {
    * Sync queued sessions (call when back online)
    */
   async syncQueuedSessions() {
-    const syncQueueFile = path16.join(TELEMETRY_DIR, "session-sync-queue.json");
-    if (!fs16.existsSync(syncQueueFile)) {
+    const syncQueueFile = path15.join(TELEMETRY_DIR, "session-sync-queue.json");
+    if (!fs15.existsSync(syncQueueFile)) {
       return { synced: 0, failed: 0 };
     }
     try {
-      const syncQueue = JSON.parse(fs16.readFileSync(syncQueueFile, "utf8"));
+      const syncQueue = JSON.parse(fs15.readFileSync(syncQueueFile, "utf8"));
       let synced = 0;
       let failed = 0;
       const remaining = [];
@@ -10199,9 +10057,9 @@ var TelemetryClient = class {
         }
       }
       if (remaining.length > 0) {
-        fs16.writeFileSync(syncQueueFile, JSON.stringify(remaining, null, 2));
+        fs15.writeFileSync(syncQueueFile, JSON.stringify(remaining, null, 2));
       } else {
-        fs16.removeSync(syncQueueFile);
+        fs15.removeSync(syncQueueFile);
       }
       return { synced, failed };
     } catch {
@@ -10252,13 +10110,13 @@ var TelemetryManager = class {
     return {
       cliVersion: package_default.version,
       platform: process.platform,
-      osVersion: os6.release(),
+      osVersion: os7.release(),
       nodeVersion: process.version,
       cpuArch: process.arch,
-      cpuCores: os6.cpus().length,
-      memoryTotal: Math.round(os6.totalmem() / 1024 / 1024),
+      cpuCores: os7.cpus().length,
+      memoryTotal: Math.round(os7.totalmem() / 1024 / 1024),
       // MB
-      memoryFree: Math.round(os6.freemem() / 1024 / 1024)
+      memoryFree: Math.round(os7.freemem() / 1024 / 1024)
       // MB
     };
   }
@@ -10478,8 +10336,8 @@ var TelemetryManager = class {
 };
 
 // src/skills/CommunitySkillsClient.ts
-import fs17 from "fs-extra";
-import path17 from "path";
+import fs16 from "fs-extra";
+import path16 from "path";
 var CommunitySkillsClient = class {
   constructor(config) {
     this.queue = [];
@@ -10487,7 +10345,7 @@ var CommunitySkillsClient = class {
     this.apiBaseUrl = config.apiBaseUrl.replace(/\/$/, "");
     this.enabled = config.enabled;
     this.deviceId = config.deviceId || this.loadDeviceId();
-    this.queueDir = config.queueDir || path17.join(AUTOHAND_HOME, "community-skills");
+    this.queueDir = config.queueDir || path16.join(AUTOHAND_HOME, "community-skills");
     this.timeout = config.timeout || 1e4;
     this.maxRetries = config.maxRetries || 3;
   }
@@ -10495,10 +10353,10 @@ var CommunitySkillsClient = class {
    * Load device ID from filesystem
    */
   loadDeviceId() {
-    const deviceIdPath = path17.join(AUTOHAND_HOME, "device-id");
+    const deviceIdPath = path16.join(AUTOHAND_HOME, "device-id");
     try {
-      if (fs17.existsSync(deviceIdPath)) {
-        return fs17.readFileSync(deviceIdPath, "utf-8").trim();
+      if (fs16.existsSync(deviceIdPath)) {
+        return fs16.readFileSync(deviceIdPath, "utf-8").trim();
       }
     } catch {
     }
@@ -10510,10 +10368,10 @@ var CommunitySkillsClient = class {
   loadQueue() {
     if (this.queueLoaded) return;
     this.queueLoaded = true;
-    const queuePath = path17.join(this.queueDir, "queue.json");
+    const queuePath = path16.join(this.queueDir, "queue.json");
     try {
-      if (fs17.existsSync(queuePath)) {
-        this.queue = fs17.readJsonSync(queuePath);
+      if (fs16.existsSync(queuePath)) {
+        this.queue = fs16.readJsonSync(queuePath);
       }
     } catch {
       this.queue = [];
@@ -10524,8 +10382,8 @@ var CommunitySkillsClient = class {
    */
   saveQueue() {
     try {
-      fs17.ensureDirSync(this.queueDir);
-      fs17.writeJsonSync(path17.join(this.queueDir, "queue.json"), this.queue);
+      fs16.ensureDirSync(this.queueDir);
+      fs16.writeJsonSync(path16.join(this.queueDir, "queue.json"), this.queue);
     } catch {
     }
   }
@@ -11202,7 +11060,7 @@ function createPersistentInput(options) {
 }
 
 // src/ui/toolOutput.ts
-import * as path18 from "path";
+import * as path17 from "path";
 var FILE_SUMMARY_TOOLS = /* @__PURE__ */ new Set([
   "read_file",
   "write_file",
@@ -11242,9 +11100,9 @@ ${truncatedContent}` : outputLines > 0 ? `
     };
   }
   if (FILE_SUMMARY_TOOLS.has(tool) && filePath) {
-    const fileName = path18.basename(filePath);
-    const dirName = path18.dirname(filePath);
-    const displayPath = dirName === "." ? fileName : `${path18.basename(dirName)}/${fileName}`;
+    const fileName = path17.basename(filePath);
+    const dirName = path17.dirname(filePath);
+    const displayPath = dirName === "." ? fileName : `${path17.basename(dirName)}/${fileName}`;
     const lines = countLines(content);
     const size = formatFileSize(Buffer.byteLength(content, "utf8"));
     return {
@@ -11265,496 +11123,6 @@ ${truncatedContent}` : outputLines > 0 ? `
   return { output: content, truncated: false, totalChars };
 }
 
-// src/core/HookManager.ts
-import { spawn as spawn3 } from "child_process";
-import { minimatch } from "minimatch";
-var DEFAULT_HOOK_TIMEOUT = 5e3;
-var HookManager = class {
-  constructor(options) {
-    this.initialized = false;
-    this.settings = options.settings ?? { enabled: true, hooks: [] };
-    this.workspaceRoot = options.workspaceRoot;
-    this.onPersist = options.onPersist;
-    this.onHookOutput = options.onHookOutput;
-  }
-  /**
-   * Initialize hooks - set up default hooks if none exist
-   */
-  async initialize() {
-    if (this.initialized) return;
-    this.initialized = true;
-    if (!this.settings.hooks || this.settings.hooks.length === 0) {
-      await this.installDefaultHooks();
-    } else {
-      await this.mergeDefaultHooks();
-    }
-    await this.ensureHookScripts();
-  }
-  /**
-   * Install default hooks (disabled by default)
-   */
-  async installDefaultHooks() {
-    try {
-      const { DEFAULT_HOOKS, SMART_COMMIT_HOOK } = await import("./defaultHooks-3G3DVF6I.js");
-      this.settings.hooks = [...DEFAULT_HOOKS, SMART_COMMIT_HOOK];
-      if (this.onPersist) {
-        await this.onPersist();
-      }
-    } catch {
-    }
-  }
-  /**
-   * Get a unique identifier for a hook (used for deduplication)
-   * Uses script filename for script-based hooks, or event+description for inline commands
-   */
-  getHookIdentifier(hook) {
-    const scriptMatch = hook.command.match(/([^/]+\.sh)$/);
-    if (scriptMatch) {
-      return `script:${scriptMatch[1]}`;
-    }
-    if (hook.description) {
-      return `${hook.event}:${hook.description}`;
-    }
-    return `${hook.event}:${hook.command}`;
-  }
-  /**
-   * Merge any missing default hooks with existing user hooks
-   * This ensures new built-in hooks are added when upgrading
-   */
-  async mergeDefaultHooks() {
-    try {
-      const { DEFAULT_HOOKS, SMART_COMMIT_HOOK } = await import("./defaultHooks-3G3DVF6I.js");
-      const allDefaults = [...DEFAULT_HOOKS, SMART_COMMIT_HOOK];
-      const existingHooks = this.settings.hooks ?? [];
-      const existingIds = new Set(existingHooks.map((h) => this.getHookIdentifier(h)));
-      const missingHooks = allDefaults.filter((h) => !existingIds.has(this.getHookIdentifier(h)));
-      if (missingHooks.length > 0) {
-        this.settings.hooks = [...existingHooks, ...missingHooks];
-        if (this.onPersist) {
-          await this.onPersist();
-        }
-      }
-    } catch (error) {
-      console.error("[hooks] Failed to merge default hooks:", error);
-    }
-  }
-  /**
-   * Ensure all hook scripts exist in ~/.autohand/hooks/
-   * Installs bundled scripts for built-in hooks
-   */
-  async ensureHookScripts() {
-    try {
-      const fs22 = await import("fs-extra");
-      const path21 = await import("path");
-      const os8 = await import("os");
-      const hooksDir = path21.join(os8.homedir(), ".autohand", "hooks");
-      await fs22.ensureDir(hooksDir);
-      const { HOOK_SCRIPTS } = await import("./defaultHooks-3G3DVF6I.js");
-      for (const [scriptName, scriptContent] of Object.entries(HOOK_SCRIPTS)) {
-        const scriptPath = path21.join(hooksDir, scriptName);
-        if (!await fs22.pathExists(scriptPath)) {
-          await fs22.writeFile(scriptPath, scriptContent, { mode: 493 });
-        }
-      }
-    } catch {
-    }
-  }
-  /**
-   * Check if hooks are globally enabled
-   */
-  isEnabled() {
-    return this.settings.enabled !== false;
-  }
-  /**
-   * Get all registered hooks
-   */
-  getHooks() {
-    return this.settings.hooks ?? [];
-  }
-  /**
-   * Get current settings
-   */
-  getSettings() {
-    return { ...this.settings };
-  }
-  /**
-   * Update settings
-   */
-  async updateSettings(settings) {
-    this.settings = { ...this.settings, ...settings };
-    if (this.onPersist) {
-      await this.onPersist();
-    }
-  }
-  /**
-   * Add a new hook
-   */
-  async addHook(hook) {
-    const hooks = this.settings.hooks ?? [];
-    hooks.push({ ...hook, enabled: hook.enabled !== false });
-    this.settings.hooks = hooks;
-    if (this.onPersist) {
-      await this.onPersist();
-    }
-  }
-  /**
-   * Remove a hook by index within its event type
-   */
-  async removeHook(event, index) {
-    const hooks = this.settings.hooks ?? [];
-    const eventHooks = hooks.filter((h) => h.event === event);
-    if (index < 0 || index >= eventHooks.length) {
-      return false;
-    }
-    const hookToRemove = eventHooks[index];
-    const globalIndex = hooks.indexOf(hookToRemove);
-    if (globalIndex !== -1) {
-      hooks.splice(globalIndex, 1);
-      this.settings.hooks = hooks;
-      if (this.onPersist) {
-        await this.onPersist();
-      }
-      return true;
-    }
-    return false;
-  }
-  /**
-   * Toggle a hook's enabled status
-   */
-  async toggleHook(event, index) {
-    const hooks = this.settings.hooks ?? [];
-    const eventHooks = hooks.filter((h) => h.event === event);
-    if (index < 0 || index >= eventHooks.length) {
-      return false;
-    }
-    const hook = eventHooks[index];
-    hook.enabled = hook.enabled === false;
-    if (this.onPersist) {
-      await this.onPersist();
-    }
-    return true;
-  }
-  /**
-   * Check if a hook's filter matches the context
-   */
-  matchesFilter(filter, context) {
-    if (!filter) return true;
-    if (filter.tool && filter.tool.length > 0) {
-      if (!context.tool || !filter.tool.includes(context.tool)) {
-        return false;
-      }
-    }
-    if (filter.path && filter.path.length > 0) {
-      if (!context.path) return false;
-      const matches = filter.path.some((pattern) => minimatch(context.path, pattern));
-      if (!matches) return false;
-    }
-    return true;
-  }
-  /**
-   * Check if a hook's regex matcher matches the context
-   * Matchers apply to tool names, notification types, session types, etc.
-   */
-  matchesMatcher(hook, context) {
-    if (!hook.matcher) return true;
-    let value = "";
-    switch (hook.event) {
-      case "pre-tool":
-      case "post-tool":
-      case "permission-request":
-        value = context.tool ?? "";
-        break;
-      case "notification":
-        value = context.notificationType ?? "";
-        break;
-      case "session-start":
-        value = context.sessionType ?? "";
-        break;
-      case "session-end":
-        value = context.sessionEndReason ?? "";
-        break;
-      case "subagent-stop":
-        value = context.subagentType ?? "";
-        break;
-      default:
-        return true;
-    }
-    try {
-      return new RegExp(hook.matcher).test(value);
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Build environment variables from hook context
-   */
-  buildEnvironment(context) {
-    const env = {
-      ...process.env,
-      HOOK_EVENT: context.event,
-      HOOK_WORKSPACE: context.workspace
-    };
-    if (context.sessionId) env.HOOK_SESSION_ID = context.sessionId;
-    if (context.tool) env.HOOK_TOOL = context.tool;
-    if (context.toolCallId) env.HOOK_TOOL_CALL_ID = context.toolCallId;
-    if (context.args) env.HOOK_ARGS = JSON.stringify(context.args);
-    if (context.success !== void 0) env.HOOK_SUCCESS = String(context.success);
-    if (context.output) env.HOOK_OUTPUT = context.output;
-    if (context.duration !== void 0) env.HOOK_DURATION = String(context.duration);
-    if (context.path) env.HOOK_PATH = context.path;
-    if (context.changeType) env.HOOK_CHANGE_TYPE = context.changeType;
-    if (context.instruction) env.HOOK_INSTRUCTION = context.instruction;
-    if (context.mentionedFiles) env.HOOK_MENTIONED_FILES = JSON.stringify(context.mentionedFiles);
-    if (context.tokensUsed !== void 0) env.HOOK_TOKENS = String(context.tokensUsed);
-    if (context.toolCallsCount !== void 0) env.HOOK_TOOL_CALLS_COUNT = String(context.toolCallsCount);
-    if (context.toolCallsInTurn !== void 0) env.HOOK_TURN_TOOL_CALLS = String(context.toolCallsInTurn);
-    if (context.turnDuration !== void 0) env.HOOK_TURN_DURATION = String(context.turnDuration);
-    if (context.error) env.HOOK_ERROR = context.error;
-    if (context.errorCode) env.HOOK_ERROR_CODE = context.errorCode;
-    if (context.sessionType) env.HOOK_SESSION_TYPE = context.sessionType;
-    if (context.sessionEndReason) env.HOOK_SESSION_END_REASON = context.sessionEndReason;
-    if (context.subagentId) env.HOOK_SUBAGENT_ID = context.subagentId;
-    if (context.subagentType) env.HOOK_SUBAGENT_TYPE = context.subagentType;
-    if (context.permissionType) env.HOOK_PERMISSION_TYPE = context.permissionType;
-    if (context.notificationType) env.HOOK_NOTIFICATION_TYPE = context.notificationType;
-    if (context.notificationMessage) env.HOOK_NOTIFICATION_MSG = context.notificationMessage;
-    return env;
-  }
-  /**
-   * Build JSON input to pass via stdin to hook
-   */
-  buildJsonInput(context) {
-    return JSON.stringify({
-      session_id: context.sessionId,
-      cwd: context.workspace,
-      hook_event_name: context.event,
-      // Tool context
-      tool_name: context.tool,
-      tool_input: context.args,
-      tool_use_id: context.toolCallId,
-      tool_response: context.output,
-      tool_success: context.success,
-      // File context
-      file_path: context.path,
-      change_type: context.changeType,
-      // Prompt context
-      instruction: context.instruction,
-      mentioned_files: context.mentionedFiles,
-      // Stop/response context
-      tokens_used: context.tokensUsed,
-      tool_calls_count: context.toolCallsCount,
-      turn_tool_calls: context.toolCallsInTurn,
-      turn_duration: context.turnDuration,
-      duration: context.duration,
-      // Error context
-      error: context.error,
-      error_code: context.errorCode,
-      // Session context
-      session_type: context.sessionType,
-      session_end_reason: context.sessionEndReason,
-      // Subagent context
-      subagent_id: context.subagentId,
-      subagent_name: context.subagentName,
-      subagent_type: context.subagentType,
-      subagent_success: context.subagentSuccess,
-      subagent_error: context.subagentError,
-      subagent_duration: context.subagentDuration,
-      // Permission context
-      permission_type: context.permissionType,
-      // Notification context
-      notification_type: context.notificationType,
-      notification_message: context.notificationMessage
-    });
-  }
-  /**
-   * Parse JSON response from hook stdout
-   */
-  parseHookResponse(stdout) {
-    const trimmed = stdout.trim();
-    if (!trimmed.startsWith("{")) {
-      return void 0;
-    }
-    try {
-      return JSON.parse(trimmed);
-    } catch {
-      return void 0;
-    }
-  }
-  /**
-   * Execute a single hook
-   */
-  async executeHook(hook, context) {
-    const startTime = Date.now();
-    const timeout = hook.timeout ?? DEFAULT_HOOK_TIMEOUT;
-    const env = this.buildEnvironment(context);
-    const jsonInput = this.buildJsonInput(context);
-    return new Promise((resolve) => {
-      const child = spawn3(hook.command, [], {
-        shell: true,
-        cwd: this.workspaceRoot,
-        env,
-        stdio: ["pipe", "pipe", "pipe"]
-        // stdin enabled for JSON input
-      });
-      let stdout = "";
-      let stderr = "";
-      let killed = false;
-      const timeoutId = setTimeout(() => {
-        killed = true;
-        child.kill("SIGTERM");
-        setTimeout(() => child.kill("SIGKILL"), 1e3);
-      }, timeout);
-      child.stdin?.write(jsonInput);
-      child.stdin?.end();
-      child.stdout?.on("data", (data) => {
-        stdout += data.toString();
-      });
-      child.stderr?.on("data", (data) => {
-        stderr += data.toString();
-      });
-      child.on("close", (code) => {
-        clearTimeout(timeoutId);
-        const duration = Date.now() - startTime;
-        const exitCode = code ?? 0;
-        const isBlockingError = exitCode === 2;
-        let response;
-        if (exitCode === 0) {
-          response = this.parseHookResponse(stdout);
-        }
-        const result = {
-          hook,
-          success: !killed && exitCode === 0,
-          stdout: stdout.trim() || void 0,
-          stderr: stderr.trim() || void 0,
-          error: killed ? `Hook timed out after ${timeout}ms` : isBlockingError ? stderr.trim() || "Hook blocked execution" : void 0,
-          duration,
-          exitCode,
-          blockingError: isBlockingError,
-          response
-        };
-        if (this.onHookOutput) {
-          this.onHookOutput(result);
-        }
-        resolve(result);
-      });
-      child.on("error", (err) => {
-        clearTimeout(timeoutId);
-        const duration = Date.now() - startTime;
-        const result = {
-          hook,
-          success: false,
-          error: err.message,
-          duration,
-          exitCode: -1
-        };
-        if (this.onHookOutput) {
-          this.onHookOutput(result);
-        }
-        resolve(result);
-      });
-    });
-  }
-  /**
-   * Get hooks for an event, including alias handling
-   */
-  getHooksForEvent(event) {
-    const hooks = this.getHooks().filter((h) => h.enabled !== false);
-    if (event === "stop") {
-      return hooks.filter((h) => h.event === "stop" || h.event === "post-response");
-    }
-    if (event === "post-response") {
-      return hooks.filter((h) => h.event === "stop" || h.event === "post-response");
-    }
-    return hooks.filter((h) => h.event === event);
-  }
-  /**
-   * Execute all hooks for an event
-   *
-   * Sync hooks are executed sequentially and block until complete.
-   * Async hooks are executed in parallel and don't block.
-   */
-  async executeHooks(event, context) {
-    if (!this.isEnabled()) {
-      return [];
-    }
-    const fullContext = {
-      ...context,
-      event,
-      workspace: this.workspaceRoot
-    };
-    const hooks = this.getHooksForEvent(event).filter(
-      (h) => this.matchesFilter(h.filter, fullContext) && this.matchesMatcher(h, fullContext)
-    );
-    if (hooks.length === 0) {
-      return [];
-    }
-    const syncHooks = hooks.filter((h) => !h.async);
-    const asyncHooks = hooks.filter((h) => h.async);
-    const results = [];
-    for (const hook of syncHooks) {
-      const result = await this.executeHook(hook, fullContext);
-      results.push(result);
-      if (result.response?.continue === false) {
-        break;
-      }
-    }
-    if (asyncHooks.length > 0) {
-      const asyncResults = await Promise.all(
-        asyncHooks.map((hook) => this.executeHook(hook, fullContext))
-      );
-      results.push(...asyncResults);
-    }
-    return results;
-  }
-  /**
-   * Test a hook by executing it with a sample context
-   */
-  async testHook(hook) {
-    const context = {
-      event: hook.event,
-      workspace: this.workspaceRoot,
-      tool: "test_tool",
-      toolCallId: "test_123",
-      args: { test: true },
-      success: true,
-      path: "test/file.ts",
-      changeType: "modify",
-      instruction: "Test instruction",
-      tokensUsed: 100
-    };
-    return this.executeHook(hook, context);
-  }
-  /**
-   * Get a summary of hooks by event
-   */
-  getSummary() {
-    const events = [
-      "pre-tool",
-      "post-tool",
-      "file-modified",
-      "pre-prompt",
-      "stop",
-      "post-response",
-      // Alias for 'stop'
-      "session-error",
-      "subagent-stop",
-      "session-start",
-      "session-end",
-      "permission-request",
-      "notification"
-    ];
-    const summary = {};
-    for (const event of events) {
-      const eventHooks = this.getHooks().filter((h) => h.event === event);
-      summary[event] = {
-        total: eventHooks.length,
-        enabled: eventHooks.filter((h) => h.enabled !== false).length
-      };
-    }
-    return summary;
-  }
-};
-
 // src/ui/promptCallback.ts
 import enquirer2 from "enquirer";
 function isExternalCallbackEnabled() {
@@ -12146,7 +11514,7 @@ var IntentDetector = class {
 };
 
 // src/core/EnvironmentBootstrap.ts
-import fs18 from "fs-extra";
+import fs17 from "fs-extra";
 import { join as join2 } from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
@@ -12242,14 +11610,14 @@ var EnvironmentBootstrap = class {
    */
   async detectPackageManager(root) {
     for (const { file, pm } of this.lockfileChecks) {
-      if (await fs18.pathExists(join2(root, file))) {
+      if (await fs17.pathExists(join2(root, file))) {
         return pm;
       }
     }
     const pkgPath = join2(root, "package.json");
-    if (await fs18.pathExists(pkgPath)) {
+    if (await fs17.pathExists(pkgPath)) {
       try {
-        const pkg = await fs18.readJson(pkgPath);
+        const pkg = await fs17.readJson(pkgPath);
         if (pkg.packageManager) {
           const match = pkg.packageManager.match(/^(bun|pnpm|yarn|npm)@/);
           if (match) {
@@ -12280,7 +11648,7 @@ var EnvironmentBootstrap = class {
     const step = { name: "Git Sync", status: "running" };
     const start = Date.now();
     try {
-      const isGit = await fs18.pathExists(join2(root, ".git"));
+      const isGit = await fs17.pathExists(join2(root, ".git"));
       if (!isGit) {
         return {
           ...step,
@@ -12361,18 +11729,18 @@ var EnvironmentBootstrap = class {
     const details = [];
     try {
       const nvmrcPath = join2(root, ".nvmrc");
-      const nvmrcExists = await fs18.pathExists(nvmrcPath);
+      const nvmrcExists = await fs17.pathExists(nvmrcPath);
       const nodeVersionPath = join2(root, ".node-version");
-      const nodeVersionExists = await fs18.pathExists(nodeVersionPath);
+      const nodeVersionExists = await fs17.pathExists(nodeVersionPath);
       if (nvmrcExists || nodeVersionExists) {
         details.push("Node version file found");
       }
       const toolVersionsPath = join2(root, ".tool-versions");
-      if (await fs18.pathExists(toolVersionsPath)) {
+      if (await fs17.pathExists(toolVersionsPath)) {
         details.push(".tool-versions found");
       }
       const rustToolchainPath = join2(root, "rust-toolchain.toml");
-      if (await fs18.pathExists(rustToolchainPath)) {
+      if (await fs17.pathExists(rustToolchainPath)) {
         details.push("Rust toolchain found");
       }
       step.status = "success";
@@ -12449,7 +11817,7 @@ var EnvironmentBootstrap = class {
 };
 
 // src/core/CodeQualityPipeline.ts
-import fs19 from "fs-extra";
+import fs18 from "fs-extra";
 import { join as join3 } from "path";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -12519,11 +11887,11 @@ var CodeQualityPipeline = class {
    */
   async detectScripts(root) {
     const pkgPath = join3(root, "package.json");
-    if (!await fs19.pathExists(pkgPath)) {
+    if (!await fs18.pathExists(pkgPath)) {
       return {};
     }
     try {
-      const pkg = await fs19.readJson(pkgPath);
+      const pkg = await fs18.readJson(pkgPath);
       const scripts = pkg.scripts || {};
       return {
         lint: this.findScript(scripts, this.scriptPatterns.lint),
@@ -13337,7 +12705,7 @@ If lint or tests fail, report the issues but do NOT commit.`;
     }
   }
   async listWorkspaceFiles() {
-    const entries = await fs20.readdir(this.runtime.workspaceRoot);
+    const entries = await fs19.readdir(this.runtime.workspaceRoot);
     const sorted = entries.sort((a, b) => a.localeCompare(b));
     console.log("\n" + chalk13.cyan("Workspace files:"));
     console.log(sorted.map((entry) => ` - ${entry}`).join("\n"));
@@ -13364,18 +12732,18 @@ If lint or tests fail, report the issues but do NOT commit.`;
   async walkWorkspace(current, acc) {
     let entries;
     try {
-      entries = await fs20.readdir(current);
+      entries = await fs19.readdir(current);
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path19.join(current, entry);
-      const rel = path19.relative(this.runtime.workspaceRoot, full);
+      const full = path18.join(current, entry);
+      const rel = path18.relative(this.runtime.workspaceRoot, full);
       if (rel === "" || this.shouldSkipPath(rel) || this.ignoreFilter.isIgnored(rel)) {
         continue;
       }
       try {
-        const stats = await fs20.stat(full);
+        const stats = await fs19.stat(full);
         if (stats.isDirectory()) {
           await this.walkWorkspace(full, acc);
         } else if (stats.isFile()) {
@@ -13745,8 +13113,8 @@ ${selectedProvider} is not configured yet. Let's set it up!
     );
   }
   async createAgentsFile() {
-    const target = path19.join(this.runtime.workspaceRoot, "AGENTS.md");
-    if (await fs20.pathExists(target)) {
+    const target = path18.join(this.runtime.workspaceRoot, "AGENTS.md");
+    if (await fs19.pathExists(target)) {
       console.log(chalk13.gray("AGENTS.md already exists in this workspace."));
       return;
     }
@@ -13754,7 +13122,7 @@ ${selectedProvider} is not configured yet. Let's set it up!
 
 Describe how Autohand should work in this repo. Include framework commands, testing requirements, and any constraints.
 `;
-    await fs20.writeFile(target, template, "utf8");
+    await fs19.writeFile(target, template, "utf8");
     console.log(chalk13.green("Created AGENTS.md template. Customize it to guide the agent."));
   }
   /**
@@ -14016,17 +13384,18 @@ Completed in ${elapsed} \xB7 ${tokens} used${queueStatus}`));
 `));
   }
   async runReactLoop(abortController) {
-    process.stderr.write(`[AGENT DEBUG] runReactLoop started
+    const debugMode = this.runtime.config.agent?.debug === true || process.env.AUTOHAND_DEBUG === "1";
+    if (debugMode) process.stderr.write(`[AGENT DEBUG] runReactLoop started
 `);
     const maxIterations = this.runtime.config.agent?.maxIterations ?? 100;
     const allTools = this.toolManager.toFunctionDefinitions();
-    process.stderr.write(`[AGENT DEBUG] Loaded ${allTools.length} tools, maxIterations=${maxIterations}
+    if (debugMode) process.stderr.write(`[AGENT DEBUG] Loaded ${allTools.length} tools, maxIterations=${maxIterations}
 `);
     this.startStatusUpdates();
     const showThinking = this.runtime.config.ui?.showThinking !== false;
     for (let iteration = 0; iteration < maxIterations; iteration += 1) {
       if (abortController.signal.aborted) {
-        process.stderr.write("[AGENT DEBUG] Abort detected at loop start, breaking\n");
+        if (debugMode) process.stderr.write("[AGENT DEBUG] Abort detected at loop start, breaking\n");
         break;
       }
       const messages = this.conversation.history();
@@ -14066,7 +13435,7 @@ ${summary}`
         this.runtime.spinner?.start("Working ...");
       }
       const messagesWithImages = this.getMessagesWithImages();
-      process.stderr.write(`[AGENT DEBUG] Calling LLM with ${messagesWithImages.length} messages, ${tools.length} tools
+      if (debugMode) process.stderr.write(`[AGENT DEBUG] Calling LLM with ${messagesWithImages.length} messages, ${tools.length} tools
 `);
       let completion;
       try {
@@ -14080,14 +13449,14 @@ ${summary}`
           maxTokens: 16e3
           // Allow large outputs for file generation
         });
-        process.stderr.write(`[AGENT DEBUG] LLM returned: content length=${completion.content?.length ?? 0}, toolCalls=${completion.toolCalls?.length ?? 0}
+        if (debugMode) process.stderr.write(`[AGENT DEBUG] LLM returned: content length=${completion.content?.length ?? 0}, toolCalls=${completion.toolCalls?.length ?? 0}
 `);
       } catch (llmError) {
         const errMsg = llmError instanceof Error ? llmError.message : String(llmError);
         const errStack = llmError instanceof Error ? llmError.stack : "";
-        process.stderr.write(`[AGENT DEBUG] LLM ERROR: ${errMsg}
+        if (debugMode) process.stderr.write(`[AGENT DEBUG] LLM ERROR: ${errMsg}
 `);
-        process.stderr.write(`[AGENT DEBUG] LLM STACK: ${errStack}
+        if (debugMode) process.stderr.write(`[AGENT DEBUG] LLM STACK: ${errStack}
 `);
         throw llmError;
       }
@@ -14096,7 +13465,7 @@ ${summary}`
         this.forceRenderSpinner();
       }
       const payload = this.parseAssistantResponse(completion);
-      process.stderr.write(`[AGENT DEBUG] Parsed payload: finalResponse=${!!payload.finalResponse}, thought=${!!payload.thought}, toolCalls=${payload.toolCalls?.length ?? 0}
+      if (debugMode) process.stderr.write(`[AGENT DEBUG] Parsed payload: finalResponse=${!!payload.finalResponse}, thought=${!!payload.thought}, toolCalls=${payload.toolCalls?.length ?? 0}
 `);
       const assistantMessage = { role: "assistant", content: completion.content };
       if (completion.toolCalls?.length) {
@@ -14105,7 +13474,7 @@ ${summary}`
       this.conversation.addMessage(assistantMessage);
       await this.saveAssistantMessage(completion.content, payload.toolCalls);
       this.updateContextUsage(this.conversation.history(), tools);
-      if (process.env.AUTOHAND_DEBUG) {
+      if (debugMode) {
         console.log(chalk13.yellow(`
 [DEBUG] Iteration ${iteration}:`));
         console.log(chalk13.yellow(`  - toolCalls: ${payload.toolCalls?.length ?? 0}`));
@@ -14244,7 +13613,7 @@ ${summary}`
           );
         }
         if (abortController.signal.aborted) {
-          process.stderr.write("[AGENT DEBUG] Abort detected after tools, breaking\n");
+          if (debugMode) process.stderr.write("[AGENT DEBUG] Abort detected after tools, breaking\n");
           break;
         }
         continue;
@@ -14282,7 +13651,7 @@ ${summary}`
         const consecutiveEmpty = (this[consecutiveEmptyKey] ?? 0) + 1;
         this[consecutiveEmptyKey] = consecutiveEmpty;
         if (consecutiveEmpty >= 3) {
-          process.stderr.write(`[AGENT DEBUG] Exiting after 3 consecutive empty responses
+          if (debugMode) process.stderr.write(`[AGENT DEBUG] Exiting after 3 consecutive empty responses
 `);
           console.log(chalk13.yellow("\n\u26A0 Model not providing response after multiple attempts. Showing available context."));
           const fallback = payload.thought || "The model did not provide a clear response. Please try rephrasing your question.";
@@ -14885,16 +14254,16 @@ ${toolSignatures}
     return normalizedSeed || null;
   }
   async fileExists(relativePath) {
-    const fullPath = path19.resolve(this.runtime.workspaceRoot, relativePath);
+    const fullPath = path18.resolve(this.runtime.workspaceRoot, relativePath);
     if (!fullPath.startsWith(this.runtime.workspaceRoot)) {
       return false;
     }
-    const exists = await fs20.pathExists(fullPath);
+    const exists = await fs19.pathExists(fullPath);
     if (!exists) {
       return false;
     }
     try {
-      const stats = await fs20.stat(fullPath);
+      const stats = await fs19.stat(fullPath);
       return stats.isFile();
     } catch {
       return false;
@@ -15202,7 +14571,7 @@ ${ctx.contents}`).join("\n\n");
       encoding: "utf8"
     });
     const gitStatus2 = git.status === 0 ? git.stdout.trim() : void 0;
-    const entries = await fs20.readdir(this.runtime.workspaceRoot);
+    const entries = await fs19.readdir(this.runtime.workspaceRoot);
     const recentFiles = entries.filter((entry) => !this.ignoreFilter.isIgnored(entry)).slice(0, 20);
     return {
       workspaceRoot: this.runtime.workspaceRoot,
@@ -15213,17 +14582,17 @@ ${ctx.contents}`).join("\n\n");
   async loadInstructionFiles() {
     const instructions = [];
     const workspace = this.runtime.workspaceRoot;
-    const agentsPath = path19.join(workspace, "AGENTS.md");
-    if (await fs20.pathExists(agentsPath)) {
-      const content = await fs20.readFile(agentsPath, "utf-8");
+    const agentsPath = path18.join(workspace, "AGENTS.md");
+    if (await fs19.pathExists(agentsPath)) {
+      const content = await fs19.readFile(agentsPath, "utf-8");
       instructions.push(`## Project Instructions (AGENTS.md)
 ${content}`);
     }
     const providerFile = this.activeProvider.includes("anthropic") || this.activeProvider === "openrouter" ? "CLAUDE.md" : this.activeProvider.includes("google") ? "GEMINI.md" : null;
     if (providerFile) {
-      const providerPath = path19.join(workspace, providerFile);
-      if (await fs20.pathExists(providerPath)) {
-        const content = await fs20.readFile(providerPath, "utf-8");
+      const providerPath = path18.join(workspace, providerFile);
+      if (await fs19.pathExists(providerPath)) {
+        const content = await fs19.readFile(providerPath, "utf-8");
         instructions.push(`## Provider Instructions (${providerFile})
 ${content}`);
       }
@@ -15810,7 +15179,7 @@ ${chalk13.gray("\u203A")} ${inputPreview}${chalk13.gray("\u258B")}`;
     }
   }
   resolveWorkspacePath(relativePath) {
-    const resolved = path19.resolve(this.runtime.workspaceRoot, relativePath);
+    const resolved = path18.resolve(this.runtime.workspaceRoot, relativePath);
     if (!resolved.startsWith(this.runtime.workspaceRoot)) {
       throw new Error(`Path ${relativePath} escapes workspace root.`);
     }
@@ -15856,9 +15225,9 @@ ${chalk13.gray("\u203A")} ${inputPreview}${chalk13.gray("\u258B")}`;
 };
 
 // src/skills/autoSkill.ts
-import fs21 from "fs-extra";
-import os7 from "os";
-import path20 from "path";
+import fs20 from "fs-extra";
+import os8 from "os";
+import path19 from "path";
 import chalk14 from "chalk";
 var AVAILABLE_TOOLS = {
   file: [
@@ -15945,7 +15314,7 @@ var ProjectAnalyzer = class {
    */
   async analyze() {
     const analysis = {
-      projectName: path20.basename(this.projectRoot),
+      projectName: path19.basename(this.projectRoot),
       languages: [],
       frameworks: [],
       patterns: [],
@@ -15957,8 +15326,8 @@ var ProjectAnalyzer = class {
       hasCI: false,
       packageManager: null
     };
-    analysis.hasGit = await fs21.pathExists(path20.join(this.projectRoot, ".git"));
-    analysis.hasCI = await fs21.pathExists(path20.join(this.projectRoot, ".github", "workflows")) || await fs21.pathExists(path20.join(this.projectRoot, ".gitlab-ci.yml")) || await fs21.pathExists(path20.join(this.projectRoot, ".circleci"));
+    analysis.hasGit = await fs20.pathExists(path19.join(this.projectRoot, ".git"));
+    analysis.hasCI = await fs20.pathExists(path19.join(this.projectRoot, ".github", "workflows")) || await fs20.pathExists(path19.join(this.projectRoot, ".gitlab-ci.yml")) || await fs20.pathExists(path19.join(this.projectRoot, ".circleci"));
     await this.analyzePackageJson(analysis);
     await this.analyzePython(analysis);
     await this.analyzeRust(analysis);
@@ -15970,7 +15339,7 @@ var ProjectAnalyzer = class {
    * Detect the current platform
    */
   detectPlatform() {
-    const platform = os7.platform();
+    const platform = os8.platform();
     if (platform === "darwin" || platform === "linux" || platform === "win32") {
       return platform;
     }
@@ -15980,12 +15349,12 @@ var ProjectAnalyzer = class {
    * Analyze package.json for Node.js projects
    */
   async analyzePackageJson(analysis) {
-    const packageJsonPath = path20.join(this.projectRoot, "package.json");
-    if (!await fs21.pathExists(packageJsonPath)) {
+    const packageJsonPath = path19.join(this.projectRoot, "package.json");
+    if (!await fs20.pathExists(packageJsonPath)) {
       return;
     }
     try {
-      const pkg = await fs21.readJson(packageJsonPath);
+      const pkg = await fs20.readJson(packageJsonPath);
       analysis.projectName = pkg.name || analysis.projectName;
       const allDeps = {
         ...pkg.dependencies,
@@ -15993,13 +15362,13 @@ var ProjectAnalyzer = class {
       };
       const depNames = Object.keys(allDeps);
       analysis.dependencies.push(...depNames);
-      if (await fs21.pathExists(path20.join(this.projectRoot, "bun.lockb"))) {
+      if (await fs20.pathExists(path19.join(this.projectRoot, "bun.lockb"))) {
         analysis.packageManager = "bun";
-      } else if (await fs21.pathExists(path20.join(this.projectRoot, "pnpm-lock.yaml"))) {
+      } else if (await fs20.pathExists(path19.join(this.projectRoot, "pnpm-lock.yaml"))) {
         analysis.packageManager = "pnpm";
-      } else if (await fs21.pathExists(path20.join(this.projectRoot, "yarn.lock"))) {
+      } else if (await fs20.pathExists(path19.join(this.projectRoot, "yarn.lock"))) {
         analysis.packageManager = "yarn";
-      } else if (await fs21.pathExists(path20.join(this.projectRoot, "package-lock.json"))) {
+      } else if (await fs20.pathExists(path19.join(this.projectRoot, "package-lock.json"))) {
         analysis.packageManager = "npm";
       }
       if (allDeps.typescript) {
@@ -16040,14 +15409,14 @@ var ProjectAnalyzer = class {
    * Analyze Python project files
    */
   async analyzePython(analysis) {
-    const requirementsPath = path20.join(this.projectRoot, "requirements.txt");
-    const pyprojectPath = path20.join(this.projectRoot, "pyproject.toml");
+    const requirementsPath = path19.join(this.projectRoot, "requirements.txt");
+    const pyprojectPath = path19.join(this.projectRoot, "pyproject.toml");
     let hasPython = false;
-    if (await fs21.pathExists(requirementsPath)) {
+    if (await fs20.pathExists(requirementsPath)) {
       hasPython = true;
       analysis.packageManager = "pip";
       try {
-        const content = await fs21.readFile(requirementsPath, "utf-8");
+        const content = await fs20.readFile(requirementsPath, "utf-8");
         const lines = content.toLowerCase();
         for (const [framework, deps] of Object.entries(PYTHON_FRAMEWORKS)) {
           if (deps.some((d) => lines.includes(d))) {
@@ -16061,7 +15430,7 @@ var ProjectAnalyzer = class {
       } catch {
       }
     }
-    if (await fs21.pathExists(pyprojectPath)) {
+    if (await fs20.pathExists(pyprojectPath)) {
       hasPython = true;
     }
     if (hasPython) {
@@ -16072,8 +15441,8 @@ var ProjectAnalyzer = class {
    * Analyze Rust project
    */
   async analyzeRust(analysis) {
-    const cargoPath = path20.join(this.projectRoot, "Cargo.toml");
-    if (await fs21.pathExists(cargoPath)) {
+    const cargoPath = path19.join(this.projectRoot, "Cargo.toml");
+    if (await fs20.pathExists(cargoPath)) {
       analysis.languages.push("rust");
       analysis.packageManager = "cargo";
     }
@@ -16082,8 +15451,8 @@ var ProjectAnalyzer = class {
    * Analyze Go project
    */
   async analyzeGo(analysis) {
-    const goModPath = path20.join(this.projectRoot, "go.mod");
-    if (await fs21.pathExists(goModPath)) {
+    const goModPath = path19.join(this.projectRoot, "go.mod");
+    if (await fs20.pathExists(goModPath)) {
       analysis.languages.push("go");
       analysis.packageManager = "go";
     }
@@ -16092,7 +15461,7 @@ var ProjectAnalyzer = class {
    * Detect additional project patterns
    */
   async detectPatterns(analysis) {
-    if (await fs21.pathExists(path20.join(this.projectRoot, "Dockerfile"))) {
+    if (await fs20.pathExists(path19.join(this.projectRoot, "Dockerfile"))) {
       analysis.patterns.push("docker");
     }
     const dbFiles = await this.findFiles("**/migrations/**", 2);
@@ -16111,13 +15480,13 @@ var ProjectAnalyzer = class {
     async function walk(dir, depth) {
       if (depth > maxDepth) return;
       try {
-        const entries = await fs21.readdir(dir, { withFileTypes: true });
+        const entries = await fs20.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path20.join(dir, entry.name);
+          const fullPath = path19.join(dir, entry.name);
           if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
             await walk(fullPath, depth + 1);
           } else if (entry.isFile()) {
-            const ext = path20.extname(entry.name);
+            const ext = path19.extname(entry.name);
             if (pattern === "*.js" && ext === ".js") {
               results.push(fullPath);
             } else if (pattern === "*.ts" && ext === ".ts") {
@@ -16262,10 +15631,10 @@ async function generateAutoSkills(analysis, llm) {
   }
 }
 async function saveSkill(skill, skillsDir) {
-  const skillDir = path20.join(skillsDir, skill.name);
-  const skillPath = path20.join(skillDir, "SKILL.md");
+  const skillDir = path19.join(skillsDir, skill.name);
+  const skillPath = path19.join(skillDir, "SKILL.md");
   try {
-    await fs21.ensureDir(skillDir);
+    await fs20.ensureDir(skillDir);
     let frontmatter = `---
 name: ${skill.name}
 description: ${skill.description}`;
@@ -16278,7 +15647,7 @@ allowed-tools: ${skill.allowedTools.join(" ")}`;
 
 `;
     const content = frontmatter + skill.body + "\n";
-    await fs21.writeFile(skillPath, content, "utf-8");
+    await fs20.writeFile(skillPath, content, "utf-8");
     return true;
   } catch {
     return false;
@@ -16314,7 +15683,7 @@ async function runAutoSkillGeneration(workspaceRoot, llm) {
     result.error = "No skills generated";
     return result;
   }
-  const skillsDir = path20.join(workspaceRoot, PROJECT_DIR_NAME, "skills");
+  const skillsDir = path19.join(workspaceRoot, PROJECT_DIR_NAME, "skills");
   for (const skill of skills) {
     const saved = await saveSkill(skill, skillsDir);
     if (saved) {
@@ -17336,10 +16705,10 @@ ${sel.text}
    * Emit hook permission-request notification
    * Called when a permission dialog is about to be shown
    */
-  emitHookPermissionRequest(tool, path21, command, args) {
+  emitHookPermissionRequest(tool, path20, command, args) {
     writeNotification(RPC_NOTIFICATIONS.HOOK_PERMISSION_REQUEST, {
       tool,
-      path: path21,
+      path: path20,
       command,
       args,
       timestamp: createTimestamp()
@@ -17407,8 +16776,8 @@ ${sel.text}
    */
   async handleGetSkillsRegistry(requestId, params) {
     try {
-      const { CommunitySkillsCache } = await import("./CommunitySkillsCache-XPDVYU3K.js");
-      const { GitHubRegistryFetcher } = await import("./GitHubRegistryFetcher-US2JJID4.js");
+      const { CommunitySkillsCache } = await import("./CommunitySkillsCache-AY3ZYDTN.js");
+      const { GitHubRegistryFetcher } = await import("./GitHubRegistryFetcher-V23KTTLM.js");
       const cache = new CommunitySkillsCache();
       const fetcher = new GitHubRegistryFetcher();
       let registry;
@@ -17467,10 +16836,10 @@ ${sel.text}
         };
       }
       const workspaceRoot = this.workspace;
-      const { CommunitySkillsCache } = await import("./CommunitySkillsCache-XPDVYU3K.js");
-      const { GitHubRegistryFetcher } = await import("./GitHubRegistryFetcher-US2JJID4.js");
-      const { AUTOHAND_PATHS: AUTOHAND_PATHS2, PROJECT_DIR_NAME: PROJECT_DIR_NAME2 } = await import("./constants-QYBEF3DB.js");
-      const path21 = await import("path");
+      const { CommunitySkillsCache } = await import("./CommunitySkillsCache-AY3ZYDTN.js");
+      const { GitHubRegistryFetcher } = await import("./GitHubRegistryFetcher-V23KTTLM.js");
+      const { AUTOHAND_PATHS: AUTOHAND_PATHS2, PROJECT_DIR_NAME: PROJECT_DIR_NAME2 } = await import("./constants-RVCOJL3L.js");
+      const path20 = await import("path");
       const cache = new CommunitySkillsCache();
       const fetcher = new GitHubRegistryFetcher();
       let registry = await cache.getRegistry();
@@ -17488,7 +16857,7 @@ ${sel.text}
           error: `Skill not found: ${params.skillName}${suggestions ? `. Did you mean: ${suggestions}?` : ""}`
         };
       }
-      const targetDir = params.scope === "project" ? path21.join(workspaceRoot, PROJECT_DIR_NAME2, "skills") : AUTOHAND_PATHS2.skills;
+      const targetDir = params.scope === "project" ? path20.join(workspaceRoot, PROJECT_DIR_NAME2, "skills") : AUTOHAND_PATHS2.skills;
       const isInstalled = await skillsRegistry.isSkillInstalled(skill.name, targetDir);
       if (isInstalled && !params.force) {
         return {
@@ -17942,7 +17311,7 @@ async function handleSingleRequest(request, adapter) {
 process.title = "autohand";
 function getGitCommit() {
   if (true) {
-    return "f429388";
+    return "1243faa";
   }
   try {
     return execSync3("git rev-parse --short HEAD", { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }).trim();
@@ -18011,7 +17380,7 @@ var ASCII_FRIEND = [
   "\u2808\u28BF\u28E6\u28E4\u28F4\u287F\u2803\u2800\u2819\u28B7\u28E6\u28E4\u28F6\u287F\u2801\u2808\u283B\u28F7\u28E4\u28E4\u287E\u281B\u2800\u2808\u28BF\u28E6\u28E4\u28E4\u2834\u2801"
 ].join("\n");
 var program = new Command();
-program.name("autohand").description("Autonomous LLM-powered coding agent CLI").version(getVersionString(), "-v, --version", "output the current version").option("-p, --prompt <text>", "Run a single instruction in command mode").option("--path <path>", "Workspace path to operate in").option("-y, --yes", "Auto-confirm risky actions", false).option("--dry-run", "Preview actions without applying mutations", false).option("--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").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("--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) => {
   if (opts.skillInstall !== void 0) {
     await runSkillInstall(opts);
     return;
@@ -18024,6 +17393,11 @@ program.name("autohand").description("Autonomous LLM-powered coding agent CLI").
     await runPatchMode(opts);
     return;
   }
+  if (opts.autoMode) {
+    opts.noWorktree = opts.worktree === false;
+    await runAutoMode(opts);
+    return;
+  }
   if (opts.mode === "rpc") {
     await runRpcMode(opts);
   } else {
@@ -18086,6 +17460,11 @@ async function runCLI(options) {
       console.log(chalk15.green("\u2713 API key saved to config\n"));
     }
     const workspaceRoot = resolveWorkspaceRoot(config, options.path);
+    const safetyCheck = checkWorkspaceSafety(workspaceRoot);
+    if (!safetyCheck.safe) {
+      printDangerousWorkspaceWarning(workspaceRoot, safetyCheck);
+      process.exit(1);
+    }
     const runtime = {
       config,
       workspaceRoot,
@@ -18108,6 +17487,10 @@ async function runCLI(options) {
         config[providerName2].model = options.model;
       }
     }
+    if (options.debug) {
+      config.agent = config.agent ?? {};
+      config.agent.debug = true;
+    }
     const llmProvider = ProviderFactory.create(config);
     const files = new FileActionManager(workspaceRoot);
     if (options.autoSkill) {
@@ -18186,9 +17569,14 @@ function printWelcome(runtime, authUser, versionCheck) {
 async function runSkillInstall(opts) {
   const config = await loadConfig(opts.config);
   const workspaceRoot = resolveWorkspaceRoot(config, opts.path);
-  const { SkillsRegistry: SkillsRegistry2 } = await import("./SkillsRegistry-7NICF6FY.js");
-  const { AUTOHAND_PATHS: AUTOHAND_PATHS2 } = await import("./constants-QYBEF3DB.js");
-  const { skillsInstall } = await import("./skills-install-RMPXN6RK.js");
+  const safetyCheck = checkWorkspaceSafety(workspaceRoot);
+  if (!safetyCheck.safe) {
+    printDangerousWorkspaceWarning(workspaceRoot, safetyCheck);
+    process.exit(1);
+  }
+  const { SkillsRegistry: SkillsRegistry2 } = await import("./SkillsRegistry-FTLVJZMA.js");
+  const { AUTOHAND_PATHS: AUTOHAND_PATHS2 } = await import("./constants-RVCOJL3L.js");
+  const { skillsInstall } = await import("./skills-install-GNTBBL46.js");
   const skillsRegistry = new SkillsRegistry2(AUTOHAND_PATHS2.skills);
   await skillsRegistry.initialize();
   await skillsRegistry.setWorkspace(workspaceRoot);
@@ -18201,8 +17589,13 @@ async function runSkillInstall(opts) {
 async function displayPermissions(opts) {
   const config = await loadConfig(opts.config);
   const workspaceRoot = resolveWorkspaceRoot(config, opts.path);
-  const { PermissionManager: PermissionManager2 } = await import("./PermissionManager-YFZI4ZZ6.js");
-  const { loadLocalProjectSettings } = await import("./localProjectPermissions-DURCNDZG.js");
+  const safetyCheck = checkWorkspaceSafety(workspaceRoot);
+  if (!safetyCheck.safe) {
+    printDangerousWorkspaceWarning(workspaceRoot, safetyCheck);
+    process.exit(1);
+  }
+  const { PermissionManager: PermissionManager2 } = await import("./PermissionManager-V2Q2OAS2.js");
+  const { loadLocalProjectSettings } = await import("./localProjectPermissions-5CXHD4DO.js");
   const localSettings = await loadLocalProjectSettings(workspaceRoot);
   const mergedSettings = {
     mode: localSettings?.permissions?.mode ?? config.permissions?.mode ?? "interactive",
@@ -18264,10 +17657,15 @@ async function runPatchMode(opts) {
     console.error(chalk15.gray('Usage: autohand --prompt "your instruction" --patch'));
     process.exit(1);
   }
-  const fs22 = await import("fs-extra");
-  const { generateUnifiedPatch, formatChangeSummary } = await import("./patch-BAAQIYSW.js");
+  const fs21 = await import("fs-extra");
+  const { generateUnifiedPatch, formatChangeSummary } = await import("./patch-RPK3BZQR.js");
   const config = await loadConfig(opts.config);
   const workspaceRoot = resolveWorkspaceRoot(config, opts.path);
+  const safetyCheck = checkWorkspaceSafety(workspaceRoot);
+  if (!safetyCheck.safe) {
+    printDangerousWorkspaceWarning(workspaceRoot, safetyCheck);
+    process.exit(1);
+  }
   if (opts.model) {
     const providerName = config.provider ?? "openrouter";
     if (config[providerName]) {
@@ -18303,8 +17701,8 @@ async function runPatchMode(opts) {
     console.error(chalk15.green(`
 \u2713 ${formatChangeSummary(changes)}`));
     if (opts.output) {
-      await fs22.default.ensureDir((await import("path")).dirname(opts.output));
-      await fs22.default.writeFile(opts.output, patch);
+      await fs21.default.ensureDir((await import("path")).dirname(opts.output));
+      await fs21.default.writeFile(opts.output, patch);
       console.error(chalk15.green(`\u2713 Patch written to ${opts.output}`));
       console.error(chalk15.gray("\nTo apply: git apply " + opts.output));
     } else {
@@ -18319,6 +17717,150 @@ Error: ${error.message}`));
     process.exit(1);
   }
 }
+async function runAutoMode(opts) {
+  if (!opts.autoMode) {
+    console.error(chalk15.red("Error: --auto-mode requires a task prompt"));
+    process.exit(1);
+  }
+  const config = await loadConfig(opts.config);
+  const workspaceRoot = resolveWorkspaceRoot(config, opts.path);
+  const safetyCheck = checkWorkspaceSafety(workspaceRoot);
+  if (!safetyCheck.safe) {
+    printDangerousWorkspaceWarning(workspaceRoot, safetyCheck);
+    process.exit(1);
+  }
+  if (opts.model) {
+    const providerName2 = config.provider ?? "openrouter";
+    if (config[providerName2]) {
+      config[providerName2].model = opts.model;
+    }
+  }
+  if (opts.debug) {
+    config.agent = config.agent ?? {};
+    config.agent.debug = true;
+  }
+  const { AutomodeManager, getAutomodeOptions } = await import("./AutomodeManager-FQQPBHAD.js");
+  const { HookManager: HookManager2 } = await import("./HookManager-VG46FXSZ.js");
+  const { SessionManager: SessionManager2 } = await import("./SessionManager-V25OJDDY.js");
+  const { MemoryManager: MemoryManager2 } = await import("./MemoryManager-AFS5EZJ2.js");
+  const readline5 = await import("readline");
+  const llmProvider = ProviderFactory.create(config);
+  const files = new FileActionManager(workspaceRoot);
+  const providerName = config.provider ?? "openrouter";
+  const modelName = opts.model ?? config[providerName]?.model ?? "unknown";
+  const sessionManager = new SessionManager2();
+  await sessionManager.initialize();
+  const session = await sessionManager.createSession(workspaceRoot, modelName);
+  session.metadata.type = "automode";
+  session.metadata.automodePrompt = opts.autoMode;
+  const memoryManager = new MemoryManager2(workspaceRoot);
+  const hookManager = new HookManager2({
+    settings: config.hooks ?? { enabled: true, hooks: [] },
+    workspaceRoot
+  });
+  const automodeManager = new AutomodeManager(config, workspaceRoot, hookManager, session, memoryManager);
+  const automodeOptions = getAutomodeOptions(opts, config);
+  if (!automodeOptions) {
+    console.error(chalk15.red("Error: Failed to parse auto-mode options"));
+    process.exit(1);
+  }
+  printBanner();
+  console.log(chalk15.bold.cyan("\n\u{1F504} Auto-Mode: Autonomous Development Loop\n"));
+  console.log(chalk15.gray("Task:"), chalk15.white(opts.autoMode));
+  console.log(chalk15.gray("Max Iterations:"), chalk15.cyan(automodeOptions.maxIterations ?? 50));
+  console.log(chalk15.gray("Completion Marker:"), chalk15.cyan(automodeOptions.completionPromise ?? "DONE"));
+  console.log(chalk15.gray("Worktree Isolation:"), chalk15.cyan(automodeOptions.useWorktree !== false ? "enabled" : "disabled"));
+  console.log();
+  if (process.stdin.isTTY) {
+    readline5.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    process.stdin.on("keypress", (_str, key) => {
+      if (key && key.name === "escape") {
+        console.log(chalk15.yellow("\n\u26A0\uFE0F  Cancelling auto-mode..."));
+        automodeManager.cancel("user_escape");
+      }
+      if (key && key.ctrl && key.name === "c") {
+        console.log(chalk15.yellow("\n\u26A0\uFE0F  Cancelling auto-mode..."));
+        automodeManager.cancel("user_escape");
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(false);
+        }
+        process.exit(0);
+      }
+    });
+  }
+  try {
+    const runtime = {
+      config,
+      workspaceRoot,
+      options: {
+        ...opts,
+        yes: true
+        // Auto-confirm in auto-mode
+      }
+    };
+    const agent = new AutohandAgent(llmProvider, files, runtime);
+    const runIteration = async (iteration, prompt, abortSignal) => {
+      const iterationPrompt = buildIterationPrompt(prompt, iteration);
+      let output = "";
+      let actions = [];
+      let success = true;
+      let error;
+      try {
+        await agent.runCommandMode(iterationPrompt);
+        actions = ["Executed agent iteration"];
+      } catch (err) {
+        success = false;
+        error = err.message;
+        console.error(chalk15.red(`Iteration error: ${error}`));
+      }
+      return {
+        success,
+        actions,
+        output,
+        error
+      };
+    };
+    await automodeManager.start(automodeOptions, runIteration);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+    const finalState = automodeManager.getState();
+    if (finalState) {
+      session.metadata.automodeIterations = finalState.currentIteration;
+      const statusText = finalState.status === "completed" ? "completed" : `ended (${finalState.status})`;
+      await sessionManager.closeSession(`Auto-mode ${statusText} after ${finalState.currentIteration} iterations: ${opts.autoMode?.slice(0, 50)}...`);
+      console.log(chalk15.gray(`
+\u{1F4C1} Session saved: ${session.metadata.sessionId}`));
+    }
+    process.exit(finalState?.status === "completed" ? 0 : 1);
+  } catch (error) {
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+    await sessionManager.closeSession(`Auto-mode failed: ${error.message}`);
+    console.error(chalk15.red(`
+Auto-mode error: ${error.message}`));
+    process.exit(1);
+  }
+}
+function buildIterationPrompt(taskPrompt, iteration) {
+  return `# Auto-Mode Task (Iteration ${iteration})
+
+## Original Task
+${taskPrompt}
+
+## Instructions
+You are running in auto-mode, an autonomous development loop. Continue working on the task above.
+
+1. Review your previous work (check git log, file changes, test results)
+2. Identify what remains to be done
+3. Make progress on the task
+4. If the task is complete, output: <promise>DONE</promise>
+
+IMPORTANT: Only output <promise>DONE</promise> when ALL requirements are fully met.
+Do not stop early - keep improving until the task is truly complete.`;
+}
 program.parseAsync();
 /**
  * @license
@@ -18412,10 +17954,6 @@ program.parseAsync();
  * Persistent Input - Always-visible input field at the bottom of the terminal
  * Uses terminal scroll regions to separate spinner output from input area
  */
-/**
- * Hook Manager - Executes lifecycle hooks based on config
- * @license Apache-2.0
- */
 /**
  * Unified Prompt Utility
  * Supports both interactive (enquirer) and external (HTTP callback) modes