autohand-cli 0.6.4 → 0.6.7

package/dist/index.js

@@ -1,7 +1,21 @@
 #!/usr/bin/env node
+import {
+  installMetadata,
+  metadata as metadata22
+} from "./chunk-W4XTDUGT.js";
+import {
+  metadata as metadata23
+} from "./chunk-NGSLABLS.js";
 import {
   metadata as metadata24
-} from "./chunk-NWXYG5PQ.js";
+} from "./chunk-37NUB5KX.js";
+import {
+  SkillsRegistry
+} from "./chunk-SKU4M27Z.js";
+import "./chunk-QHPFA6OE.js";
+import {
+  metadata as metadata15
+} from "./chunk-2NUX2RAI.js";
 import {
   metadata as metadata16
 } from "./chunk-YWKZF2SA.js";
@@ -11,16 +25,16 @@ import {
 import {
   metadata as metadata18,
   package_default
-} from "./chunk-6MCXWSR3.js";
+} from "./chunk-H4RPZD6H.js";
 import {
   metadata as metadata19
-} from "./chunk-MRQV5HMC.js";
+} from "./chunk-DE7YC5MB.js";
 import {
   metadata as metadata20
-} from "./chunk-KZ2UXXLH.js";
+} from "./chunk-BAHUKJJR.js";
 import {
   getAuthClient
-} from "./chunk-KT55HW6V.js";
+} from "./chunk-CHQMK2ZG.js";
 import {
   ThemeProvider,
   getProviderConfig,
@@ -31,33 +45,24 @@ import {
   resolveWorkspaceRoot,
   saveConfig,
   useTheme
-} from "./chunk-UBGEAEKS.js";
+} from "./chunk-AY2XV7TH.js";
 import {
   metadata as metadata21
-} from "./chunk-5N3QP5LJ.js";
-import {
-  metadata as metadata22
-} from "./chunk-NEAJ2UWG.js";
+} from "./chunk-YDH2BMEN.js";
 import {
-  metadata as metadata23,
-  validateSkillFrontmatter
-} from "./chunk-2TPGTNNY.js";
+  metadata as metadata7
+} from "./chunk-SVLBJMYO.js";
 import {
   AgentRegistry,
   metadata as metadata8
-} from "./chunk-6FEZ6JAQ.js";
+} from "./chunk-7HB7GSQF.js";
 import {
   metadata as metadata9
-} from "./chunk-PRZTK2FX.js";
+} from "./chunk-5WKR4HIB.js";
 import {
   metadata as metadata10
-} from "./chunk-4H3B46YX.js";
-import {
-  AUTOHAND_FILES,
-  AUTOHAND_HOME,
-  AUTOHAND_PATHS,
-  PROJECT_DIR_NAME
-} from "./chunk-737A24RB.js";
+} from "./chunk-MWLAHCU7.js";
+import "./chunk-7BYSXAKS.js";
 import {
   metadata as metadata11
 } from "./chunk-I4HVBWYF.js";
@@ -72,8 +77,11 @@ import {
   metadata as metadata14
 } from "./chunk-XDVG3NM4.js";
 import {
-  metadata as metadata15
-} from "./chunk-2NUX2RAI.js";
+  AUTOHAND_FILES,
+  AUTOHAND_HOME,
+  AUTOHAND_PATHS,
+  PROJECT_DIR_NAME
+} from "./chunk-FUEL6BK7.js";
 import {
   metadata
 } from "./chunk-KZ7VMQTC.js";
@@ -93,9 +101,6 @@ import {
 import {
   metadata as metadata6
 } from "./chunk-QJ53OSGF.js";
-import {
-  metadata as metadata7
-} from "./chunk-SVLBJMYO.js";
 import {
   __commonJS,
   __toESM
@@ -2087,6 +2092,18 @@ var GitIgnoreParser = class {
 };
 
 // src/actions/filesystem.ts
+var FILE_LIMITS = {
+  /** Maximum file size for read operations (10MB) */
+  MAX_READ_SIZE: 10 * 1024 * 1024,
+  /** Maximum file size for write operations (50MB) */
+  MAX_WRITE_SIZE: 50 * 1024 * 1024,
+  /** Maximum number of files in a single directory listing */
+  MAX_DIR_ENTRIES: 1e4,
+  /** Maximum search results to return */
+  MAX_SEARCH_RESULTS: 1e3,
+  /** Maximum undo stack size */
+  MAX_UNDO_STACK: 100
+};
 var FileActionManager = class {
   constructor(workspaceRoot) {
     this.undoStack = [];
@@ -2101,12 +2118,27 @@ var FileActionManager = class {
     if (!exists) {
       throw new Error(`File ${target} not found in workspace.`);
     }
+    const stats = await fs3.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 fs3.readFile(filePath, "utf8");
   }
   async writeFile(target, contents) {
+    const contentSize = Buffer.byteLength(contents, "utf8");
+    if (contentSize > FILE_LIMITS.MAX_WRITE_SIZE) {
+      const sizeMB = (contentSize / 1024 / 1024).toFixed(2);
+      const limitMB = (FILE_LIMITS.MAX_WRITE_SIZE / 1024 / 1024).toFixed(0);
+      throw new Error(`Content too large to write (${sizeMB}MB). Maximum allowed: ${limitMB}MB`);
+    }
     const filePath = this.resolvePath(target);
     await fs3.ensureDir(path2.dirname(filePath));
     const previous = await fs3.pathExists(filePath) ? await fs3.readFile(filePath, "utf8") : "";
+    if (this.undoStack.length >= FILE_LIMITS.MAX_UNDO_STACK) {
+      this.undoStack.shift();
+    }
     this.undoStack.push({ absolutePath: filePath, previousContents: previous });
     await fs3.writeFile(filePath, contents, "utf8");
   }
@@ -2139,6 +2171,9 @@ var FileActionManager = class {
       "never",
       "--no-binary",
       // Skip binary files
+      "--max-count",
+      String(FILE_LIMITS.MAX_SEARCH_RESULTS),
+      // Enforce result limit
       "--glob",
       "!*.{exe,dll,so,dylib,bin,o,a,lib,pyc,pyo,class,jar,war,ear}",
       "--glob",
@@ -2168,7 +2203,7 @@ var FileActionManager = class {
       encoding: "utf8"
     });
     if (rgResult.status === 0 && rgResult.stdout) {
-      return rgResult.stdout.trim().split("\n").filter(Boolean).map((line) => {
+      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: path2.relative(this.workspaceRoot, path2.join(searchDir, file)),
@@ -2176,6 +2211,7 @@ var FileActionManager = class {
           text: rest.join(":")
         };
       });
+      return results;
     }
     return this.walkFallback(query, searchDir);
   }
@@ -2300,13 +2336,37 @@ var FileActionManager = class {
     if (!await fs3.pathExists(filePath)) {
       return "";
     }
+    const stats = await fs3.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 fs3.readFile(filePath, "utf8");
   }
   resolvePath(target) {
     const normalized = path2.isAbsolute(target) ? target : path2.join(this.workspaceRoot, target);
     const resolved = path2.resolve(normalized);
-    const rootWithSep = this.workspaceRoot.endsWith(path2.sep) ? this.workspaceRoot : `${this.workspaceRoot}${path2.sep}`;
-    if (resolved !== this.workspaceRoot && !resolved.startsWith(rootWithSep)) {
+    let realPath;
+    try {
+      realPath = fs3.realpathSync(resolved);
+    } catch {
+      const parentDir = path2.dirname(resolved);
+      try {
+        const realParent = fs3.realpathSync(parentDir);
+        realPath = path2.join(realParent, path2.basename(resolved));
+      } catch {
+        realPath = resolved;
+      }
+    }
+    let realWorkspaceRoot;
+    try {
+      realWorkspaceRoot = fs3.realpathSync(this.workspaceRoot);
+    } catch {
+      realWorkspaceRoot = this.workspaceRoot;
+    }
+    const rootWithSep = realWorkspaceRoot.endsWith(path2.sep) ? realWorkspaceRoot : `${realWorkspaceRoot}${path2.sep}`;
+    if (realPath !== realWorkspaceRoot && !realPath.startsWith(rootWithSep)) {
       throw new Error(`Path ${target} escapes the workspace root ${this.workspaceRoot}`);
     }
     return resolved;
@@ -2314,7 +2374,7 @@ var FileActionManager = class {
   walkFallback(query, baseDir) {
     const hits = [];
     const stack = [baseDir];
-    while (stack.length) {
+    while (stack.length && hits.length < FILE_LIMITS.MAX_SEARCH_RESULTS) {
       const current = stack.pop();
       if (!current) {
         continue;
@@ -2336,7 +2396,8 @@ var FileActionManager = class {
         } else if (stats.isFile()) {
           const contents = fs3.readFileSync(current, "utf8");
           const lines = contents.split(/\r?\n/);
-          lines.forEach((line, idx) => {
+          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: path2.relative(this.workspaceRoot, current),
@@ -2344,7 +2405,7 @@ var FileActionManager = class {
                 text: line.trim()
               });
             }
-          });
+          }
         }
       } catch {
         continue;
@@ -3113,8 +3174,8 @@ var ProviderFactory = class {
 
 // src/core/agent.ts
 import chalk13 from "chalk";
-import fs22 from "fs-extra";
-import path20 from "path";
+import fs20 from "fs-extra";
+import path19 from "path";
 import { randomUUID } from "crypto";
 import { spawnSync as spawnSync5 } from "child_process";
 import ora from "ora";
@@ -3334,12 +3395,12 @@ var MentionPreview = class {
         const dir = parts.length ? parts.join("/") + "/" : "";
         if (isSelected) {
           const highlighted = chalk2.cyan(filename);
-          const path23 = dir ? chalk2.gray(dir) : "";
-          return `${pointer} ${path23}${highlighted}`;
+          const path22 = dir ? chalk2.gray(dir) : "";
+          return `${pointer} ${path22}${highlighted}`;
         }
         const dimmedFilename = chalk2.white(filename);
-        const path22 = dir ? chalk2.gray(dir) : "";
-        return `${pointer} ${path22}${dimmedFilename}`;
+        const path21 = dir ? chalk2.gray(dir) : "";
+        return `${pointer} ${path21}${dimmedFilename}`;
       }
       const text = isSelected ? chalk2.cyan(entry) : entry;
       return `${pointer} ${text}`;
@@ -3549,6 +3610,25 @@ function parseBase64DataUrl(dataUrl) {
     return void 0;
   }
 }
+var VISION_MODELS = [
+  "claude-3-opus",
+  "claude-3-sonnet",
+  "claude-3-haiku",
+  "claude-3.5-sonnet",
+  "claude-3.5-haiku",
+  "claude-4",
+  "gpt-4-vision",
+  "gpt-4o",
+  "gpt-4o-mini",
+  "gemini-pro-vision",
+  "gemini-1.5-pro",
+  "gemini-1.5-flash",
+  "gemini-2.0"
+];
+function supportsVision(model) {
+  const lowerModel = model.toLowerCase();
+  return VISION_MODELS.some((v) => lowerModel.includes(v.toLowerCase()));
+}
 
 // src/ui/box.ts
 import chalk3 from "chalk";
@@ -4041,6 +4121,25 @@ function calculateContextUsage(messages, tools, model) {
 
 // src/actions/git.ts
 import { spawnSync as spawnSync3 } from "child_process";
+var GIT_SAFETY = {
+  /** Branches where force push is blocked */
+  PROTECTED_BRANCHES: ["main", "master", "develop", "production", "staging"],
+  /** Maximum commits to push at once (to prevent accidental mass pushes) */
+  MAX_COMMITS_PER_PUSH: 50
+};
+function getCurrentBranch(cwd) {
+  const result = spawnSync3("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd, encoding: "utf8" });
+  return result.stdout?.trim() || "";
+}
+function getCommitsAhead(cwd, remote = "origin", branch) {
+  const currentBranch = branch || getCurrentBranch(cwd);
+  if (!currentBranch) return 0;
+  const result = spawnSync3("git", ["rev-list", "--count", `${remote}/${currentBranch}..HEAD`], {
+    cwd,
+    encoding: "utf8"
+  });
+  return parseInt(result.stdout?.trim() || "0", 10) || 0;
+}
 function applyGitPatch(cwd, patch) {
   const result = spawnSync3("git", ["apply", "-"], {
     cwd,
@@ -4239,6 +4338,12 @@ function gitCherryPickContinue(cwd) {
   return "Cherry-pick continued";
 }
 function gitRebase(cwd, upstream, options = {}) {
+  const currentBranch = getCurrentBranch(cwd);
+  if (GIT_SAFETY.PROTECTED_BRANCHES.includes(currentBranch)) {
+    throw new Error(
+      `Rebasing protected branch "${currentBranch}" is blocked. Protected branches should not be rebased as it rewrites history. Use merge instead, or switch to a feature branch first.`
+    );
+  }
   const args = ["rebase"];
   if (options.onto) {
     args.push("--onto", options.onto);
@@ -4275,6 +4380,17 @@ function gitRebaseSkip(cwd) {
   return "Skipped commit and continued rebase";
 }
 function gitMerge(cwd, branch, options = {}) {
+  const localBranches = spawnSync3("git", ["branch", "--list"], { cwd, encoding: "utf8" });
+  const remoteBranches = spawnSync3("git", ["branch", "-r", "--list"], { cwd, encoding: "utf8" });
+  const allBranches = (localBranches.stdout || "") + (remoteBranches.stdout || "");
+  const branchExists = allBranches.split("\n").some(
+    (b) => b.trim().replace("* ", "") === branch || b.trim() === `origin/${branch}` || b.trim() === branch
+  );
+  if (!branchExists) {
+    throw new Error(
+      `Branch "${branch}" not found locally or in remotes. For security, only existing branches can be merged. Run 'git fetch' first if the branch exists remotely.`
+    );
+  }
   const args = ["merge"];
   if (options.noCommit) {
     args.push("--no-commit");
@@ -4325,6 +4441,16 @@ function gitAdd(cwd, paths) {
   return result.stdout || `Staged ${paths.join(", ")}`;
 }
 function gitReset(cwd, mode = "mixed", ref) {
+  if (mode === "hard") {
+    const currentBranch = getCurrentBranch(cwd);
+    if (GIT_SAFETY.PROTECTED_BRANCHES.includes(currentBranch)) {
+      throw new Error(
+        `Hard reset on protected branch "${currentBranch}" is blocked for safety.
+Protected branches: ${GIT_SAFETY.PROTECTED_BRANCHES.join(", ")}
+Use soft or mixed reset instead, or switch to a feature branch.`
+      );
+    }
+  }
   const args = ["reset", `--${mode}`];
   if (ref) {
     args.push(ref);
@@ -4519,9 +4645,22 @@ function gitPull(cwd, remote, branch) {
   return result.stdout || "Pulled";
 }
 function gitPush(cwd, remote, branch, options = {}) {
+  const targetRemote = remote || "origin";
+  const targetBranch = branch || getCurrentBranch(cwd);
+  if (options.force && GIT_SAFETY.PROTECTED_BRANCHES.includes(targetBranch)) {
+    throw new Error(
+      `Force push to protected branch "${targetBranch}" is blocked. Protected branches: ${GIT_SAFETY.PROTECTED_BRANCHES.join(", ")}`
+    );
+  }
+  const commitsAhead = getCommitsAhead(cwd, targetRemote, targetBranch);
+  if (commitsAhead > GIT_SAFETY.MAX_COMMITS_PER_PUSH) {
+    throw new Error(
+      `Too many commits to push (${commitsAhead}). Maximum allowed: ${GIT_SAFETY.MAX_COMMITS_PER_PUSH}. This limit exists to prevent accidental large pushes. Push manually if intentional.`
+    );
+  }
   const args = ["push"];
   if (options.force) {
-    args.push("--force");
+    args.push("--force-with-lease");
   }
   if (options.setUpstream) {
     args.push("--set-upstream");
@@ -4895,6 +5034,7 @@ var SLASH_COMMANDS = [
   metadata20,
   metadata21,
   metadata22,
+  installMetadata,
   metadata23,
   metadata24
 ];
@@ -5944,25 +6084,30 @@ var ToolManager = class _ToolManager {
       const requiresApproval = this.toolFilter.requiresApproval(call.tool, definition?.requiresApproval);
       if (requiresApproval) {
         let message = definition?.approvalMessage ?? `Allow tool ${call.tool}?`;
+        let permContext = { tool: call.tool };
         if (call.tool === "run_command" && call.args) {
-          const cmd = call.args.command || "";
+          const cmd = String(call.args.command || "");
           const args = Array.isArray(call.args.args) ? call.args.args.join(" ") : "";
           const fullCommand = args ? `${cmd} ${args}` : cmd;
           const dir = call.args.directory ? ` (in ${call.args.directory})` : "";
           message = `Run this command${dir}?
   $ ${fullCommand}`;
+          permContext.command = fullCommand;
         } else if (call.tool === "delete_path" && call.args?.path) {
           message = `Delete this path?
   ${call.args.path}`;
+          permContext.path = String(call.args.path);
         } else if (call.tool === "write_file" && call.args?.path) {
           message = `Write to this file?
   ${call.args.path}`;
+          permContext.path = String(call.args.path);
         } else if (call.tool === "multi_file_edit" && call.args?.file_path) {
           const editCount = Array.isArray(call.args.edits) ? call.args.edits.length : 0;
           message = `Edit this file (${editCount} change${editCount === 1 ? "" : "s"})?
   ${call.args.file_path}`;
+          permContext.path = String(call.args.file_path);
         }
-        const confirmed = await this.confirmApproval(message);
+        const confirmed = await this.confirmApproval(message, permContext);
         if (!confirmed) {
           results.push({
             tool: call.tool,
@@ -7600,6 +7745,96 @@ function mergePermissions(globalSettings, localSettings) {
 }
 
 // src/permissions/PermissionManager.ts
+var DEFAULT_SECURITY_BLACKLIST = [
+  // === Sensitive Files (read/write blocked) ===
+  // Environment files with secrets
+  "read_file:.env",
+  "read_file:.env.*",
+  "read_file:*.env",
+  "write_file:.env",
+  "write_file:.env.*",
+  "write_file:*.env",
+  // Git credentials and config
+  "read_file:.git/config",
+  "write_file:.git/config",
+  "read_file:.git/credentials",
+  "write_file:.git/credentials",
+  "read_file:.gitconfig",
+  "write_file:.gitconfig",
+  // SSH keys
+  "read_file:*/.ssh/*",
+  "write_file:*/.ssh/*",
+  "read_file:*/id_rsa*",
+  "read_file:*/id_ed25519*",
+  "read_file:*/id_ecdsa*",
+  "write_file:*/id_rsa*",
+  "write_file:*/id_ed25519*",
+  // Cloud credentials
+  "read_file:*/.aws/credentials",
+  "read_file:*/.aws/config",
+  "write_file:*/.aws/*",
+  "read_file:*/.azure/*",
+  "write_file:*/.azure/*",
+  "read_file:*/.gcloud/*",
+  "write_file:*/.gcloud/*",
+  // Private keys and certificates
+  "read_file:*.pem",
+  "read_file:*.key",
+  "read_file:*.p12",
+  "read_file:*.pfx",
+  "write_file:*.pem",
+  "write_file:*.key",
+  // GPG keys
+  "read_file:*/.gnupg/*",
+  "write_file:*/.gnupg/*",
+  // NPM tokens
+  "read_file:.npmrc",
+  "write_file:.npmrc",
+  // Docker credentials
+  "read_file:*/.docker/config.json",
+  "write_file:*/.docker/config.json",
+  // Kubernetes credentials
+  "read_file:*/.kube/config",
+  "write_file:*/.kube/config",
+  // === Dangerous Commands ===
+  // Environment exposure
+  "run_command:printenv",
+  "run_command:printenv *",
+  "run_command:env",
+  "run_command:export",
+  "run_command:set",
+  // System information
+  "run_command:cat /etc/passwd",
+  "run_command:cat /etc/shadow",
+  "run_command:cat /etc/sudoers",
+  // Privilege escalation
+  "run_command:sudo *",
+  "run_command:su *",
+  "run_command:doas *",
+  // Destructive operations
+  "run_command:rm -rf /",
+  "run_command:rm -rf /*",
+  "run_command:rm -rf ~",
+  "run_command:rm -rf ~/*",
+  "run_command:dd if=* of=/dev/*",
+  "run_command:mkfs*",
+  "run_command:wipefs*",
+  "run_command:shred*",
+  // Remote code execution
+  "run_command:curl * | *sh",
+  "run_command:wget * | *sh",
+  "run_command:curl *|*sh",
+  "run_command:wget *|*sh",
+  // Network tools that can exfiltrate
+  "run_command:nc -e*",
+  "run_command:ncat -e*",
+  "run_command:netcat -e*",
+  // Credential theft
+  "run_command:cat */.ssh/*",
+  "run_command:cat */.aws/*",
+  "run_command:cat *.pem",
+  "run_command:cat *.key"
+];
 var PermissionManager = class {
   constructor(options = {}) {
     this.sessionCache = /* @__PURE__ */ new Map();
@@ -7608,10 +7843,11 @@ var PermissionManager = class {
     const settings = isOptions ? options.settings ?? {} : options;
     this.onPersist = isOptions ? options.onPersist : void 0;
     this.workspaceRoot = isOptions ? options.workspaceRoot : void 0;
+    const userBlacklist = settings.blacklist ?? [];
     this.settings = {
       mode: "interactive",
       whitelist: [],
-      blacklist: [],
+      blacklist: userBlacklist,
       rules: [],
       rememberSession: true,
       ...settings
@@ -7655,6 +7891,9 @@ var PermissionManager = class {
    * Check if an action should be allowed, denied, or prompted
    */
   checkPermission(context) {
+    if (this.isSecurityBlacklisted(context)) {
+      return { allowed: false, reason: "blacklisted" };
+    }
     const cacheKey = this.getCacheKey(context);
     if (this.settings.rememberSession && this.sessionCache.has(cacheKey)) {
       return {
@@ -7733,12 +7972,19 @@ var PermissionManager = class {
     return `${tool}:${value}`;
   }
   /**
-   * Check if context matches blacklist (uses merged global + local settings)
+   * Check if context matches the immutable security blacklist
+   * This check CANNOT be bypassed by any mode, whitelist, or user setting
+   */
+  isSecurityBlacklisted(context) {
+    return DEFAULT_SECURITY_BLACKLIST.some((pattern) => this.matchesPattern(context, pattern));
+  }
+  /**
+   * Check if context matches user blacklist (can be modified by user)
    */
   isBlacklisted(context) {
     const merged = this.getMergedSettings();
-    const blacklist = merged.blacklist || [];
-    return blacklist.some((pattern) => this.matchesPattern(context, pattern));
+    const userBlacklist = merged.blacklist || [];
+    return userBlacklist.some((pattern) => this.matchesPattern(context, pattern));
   }
   /**
    * Check if context matches whitelist (uses merged global + local settings)
@@ -8332,7 +8578,7 @@ var SecurityScanner = class {
 
 // src/core/actionExecutor.ts
 import { execSync as execSync2 } from "child_process";
-var ActionExecutor = class {
+var ActionExecutor = class _ActionExecutor {
   constructor(deps) {
     this.deps = deps;
     this.searchCache = /* @__PURE__ */ new Map();
@@ -8420,8 +8666,8 @@ var ActionExecutor = class {
           throw new Error(`write_file requires a "path" argument. Received arguments: [${receivedKeys}]`);
         }
         const filePath = this.resolveWorkspacePath(action.path);
-        const fs24 = await import("fs-extra");
-        const exists = this.files.root && await fs24.pathExists(filePath);
+        const fs22 = await import("fs-extra");
+        const exists = this.files.root && await fs22.pathExists(filePath);
         const oldContent = exists ? await this.files.readFile(action.path) : "";
         const newContent = this.pickText(action.contents, action.content) ?? "";
         if (!exists) {
@@ -8442,7 +8688,8 @@ var ActionExecutor = class {
             const preview = newContent.length > 500 ? newContent.substring(0, 500) + "\n... (truncated)" : newContent;
             console.log(chalk6.gray(preview));
             const confirmed = await this.confirmDangerousAction(
-              `Create new file ${action.path}?`
+              `Create new file ${action.path}?`,
+              { tool: "write_file", path: action.path }
             );
             await this.permissionManager.recordDecision(permContext, confirmed);
             if (!confirmed) {
@@ -8546,7 +8793,10 @@ ${hit.snippet}`).join("\n\n");
         if (!action.path) {
           throw new Error('delete_path requires a "path" argument.');
         }
-        const confirmed = await this.confirmDangerousAction(`Delete ${action.path}?`);
+        const confirmed = await this.confirmDangerousAction(
+          `Delete ${action.path}?`,
+          { tool: "delete_path", path: action.path }
+        );
         if (!confirmed) {
           return `Skipped deleting ${action.path}`;
         }
@@ -8801,8 +9051,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 path22 of result.synced) {
-            lines.push(`  \u2713 ${path22}`);
+          for (const path21 of result.synced) {
+            lines.push(`  \u2713 ${path21}`);
           }
           lines.push("");
         }
@@ -9141,10 +9391,37 @@ ${result.removed.map((p) => `  - ${p}`).join("\n")}`;
         if (builtInNames.includes(action.name)) {
           throw new Error(`Cannot create meta-tool "${action.name}": conflicts with built-in tool`);
         }
-        const dangerousPatterns = ["rm -rf /", "dd if=", "mkfs.", ":(){:|:&};:"];
-        for (const pattern of dangerousPatterns) {
-          if (action.handler.includes(pattern)) {
-            throw new Error(`Handler contains dangerous pattern: ${pattern}`);
+        const dangerousPatterns = [
+          // Destructive file operations
+          { pattern: /rm\s+(-[rf]+\s+)*\/(?!\w)/i, description: "rm with root path" },
+          { pattern: /rm\s+.*--no-preserve-root/i, description: "rm --no-preserve-root" },
+          { pattern: /dd\s+.*(?:of|if)=\/dev\/[sh]d/i, description: "dd to disk device" },
+          { pattern: /mkfs\./i, description: "filesystem format" },
+          { pattern: /wipefs/i, description: "disk wipe" },
+          // Privilege escalation
+          { pattern: /\bsudo\s/i, description: "sudo command" },
+          { pattern: /\bsu\s+-?\s*\w/i, description: "su command" },
+          { pattern: /chmod\s+[0-7]*7[0-7]*/i, description: "world-writable chmod" },
+          { pattern: /chown\s+root/i, description: "chown to root" },
+          // Remote code execution
+          { pattern: /curl\s+.*\|\s*(ba)?sh/i, description: "curl | bash" },
+          { pattern: /wget\s+.*\|\s*(ba)?sh/i, description: "wget | sh" },
+          { pattern: /\beval\s+[`$]/i, description: "eval with expansion" },
+          // Fork bomb and resource exhaustion
+          { pattern: /:\(\)\s*\{\s*:\s*\|\s*:\s*&\s*\}\s*;/i, description: "fork bomb" },
+          { pattern: /while\s+true.*do.*done/i, description: "infinite loop" },
+          // Reverse shell indicators
+          { pattern: /nc\s+.*-e\s*\/bin/i, description: "netcat reverse shell" },
+          { pattern: /ncat\s+.*-e\s*\/bin/i, description: "ncat reverse shell" },
+          { pattern: /bash\s+-i\s+>&?\s*\/dev\/tcp/i, description: "bash reverse shell" },
+          // Dangerous network operations
+          { pattern: /iptables\s+-F/i, description: "flush firewall rules" },
+          // Crypto operations that could lock out user
+          { pattern: /gpg\s+.*--encrypt.*-r\s+\S+\s+\//i, description: "gpg encrypt root" }
+        ];
+        for (const { pattern, description } of dangerousPatterns) {
+          if (pattern.test(action.handler)) {
+            throw new Error(`Handler contains dangerous pattern: ${description}`);
           }
         }
         const saved = await this.toolsRegistry.saveMetaTool({
@@ -9337,7 +9614,10 @@ ${result.removed.map((p) => `  - ${p}`).join("\n")}`;
       if (this.isDestructiveCommand(definition.command)) {
         console.log(chalk6.red("Warning: command may be destructive."));
       }
-      const answer = await this.confirmDangerousAction("Add and run this custom command?");
+      const answer = await this.confirmDangerousAction(
+        "Add and run this custom command?",
+        { tool: "run_command", command: definition.command }
+      );
       if (!answer) {
         return "Custom command rejected by user.";
       }
@@ -9350,6 +9630,19 @@ ${result.removed.map((p) => `  - ${p}`).join("\n")}`;
     const lowered = command.toLowerCase();
     return lowered.includes("rm ") || lowered.includes("sudo ") || lowered.includes("dd ");
   }
+  static {
+    /**
+     * Shell metacharacters that could enable command injection
+     */
+    this.SHELL_METACHARACTERS = /[|;&$`><(){}[\]!#*?~'"\\]/;
+  }
+  /**
+   * Safely escape a value for shell interpolation
+   * Uses single quotes which prevent all shell expansion except for single quotes themselves
+   */
+  shellEscape(value) {
+    return "'" + value.replace(/'/g, `'"'"'`) + "'";
+  }
   /**
    * Execute a dynamic meta-tool by substituting {{param}} placeholders
    */
@@ -9363,18 +9656,39 @@ ${result.removed.map((p) => `  - ${p}`).join("\n")}`;
       if (value === void 0 || value === null) {
         throw new Error(`Missing required parameter "${paramName}" for meta-tool "${metaTool.name}"`);
       }
-      const escapedValue = String(value).replace(/(["`$\\])/g, "\\$1");
-      command = command.replace(new RegExp(`\\{\\{${paramName}\\}\\}`, "g"), escapedValue);
+      const stringValue = String(value);
+      let safeValue;
+      if (_ActionExecutor.SHELL_METACHARACTERS.test(stringValue)) {
+        safeValue = this.shellEscape(stringValue);
+        console.log(chalk6.yellow(`   \u26A0 Parameter "${paramName}" contains shell metacharacters, escaped for safety`));
+      } else {
+        safeValue = stringValue;
+      }
+      command = command.replace(new RegExp(`\\{\\{${paramName}\\}\\}`, "g"), safeValue);
     }
     console.log(chalk6.cyan(`
 \u{1F527} Running meta-tool: ${metaTool.name}`));
     console.log(chalk6.gray(`   $ ${command}`));
-    const result = await runCommand(command, [], this.runtime.workspaceRoot);
+    const result = await runCommand(command, [], this.runtime.workspaceRoot, { shell: true });
     return [`$ ${command}`, result.stdout, result.stderr].filter(Boolean).join("\n");
   }
   applySearchReplaceBlocks(content, blocks) {
-    const MARKERS = { search: "<<<<<<< SEARCH", div: "=======", replace: ">>>>>>> REPLACE" };
     let result = content;
+    if (blocks.includes("SEARCH:") && blocks.includes("REPLACE:") && !blocks.includes("<<<<<<< SEARCH")) {
+      const searchIdx = blocks.indexOf("SEARCH:");
+      const replaceIdx = blocks.indexOf("REPLACE:");
+      if (searchIdx !== -1 && replaceIdx !== -1 && replaceIdx > searchIdx) {
+        const searchText = blocks.slice(searchIdx + 7, replaceIdx).trim();
+        const replaceText = blocks.slice(replaceIdx + 8).trim();
+        const idx = result.indexOf(searchText);
+        if (idx === -1) {
+          throw new Error(`SEARCH text not found: "${searchText.slice(0, 50)}..."`);
+        }
+        result = result.slice(0, idx) + replaceText + result.slice(idx + searchText.length);
+        return result;
+      }
+    }
+    const MARKERS = { search: "<<<<<<< SEARCH", div: "=======", replace: ">>>>>>> REPLACE" };
     let remaining = blocks;
     while (remaining.includes(MARKERS.search)) {
       const searchStart = remaining.indexOf(MARKERS.search);
@@ -9688,6 +10002,12 @@ var SlashCommandHandler = class {
     this.commandMap = /* @__PURE__ */ new Map();
     commands.forEach((cmd) => this.commandMap.set(cmd.command, cmd));
   }
+  /**
+   * Check if a command is supported (exists in the command map)
+   */
+  isCommandSupported(command) {
+    return this.commandMap.has(command);
+  }
   async handle(command, args = []) {
     const meta = this.commandMap.get(command);
     if (!meta) {
@@ -9718,7 +10038,7 @@ var SlashCommandHandler = class {
           return help();
         }
         case "/agents": {
-          const { handler } = await import("./agents-OJWYZN6X.js");
+          const { handler } = await import("./agents-NB5VQN6H.js");
           const output = await handler();
           if (output) {
             console.log(output);
@@ -9727,11 +10047,11 @@ var SlashCommandHandler = class {
         }
         case "/agents new":
         case "/agents-new": {
-          const { createAgent } = await import("./agents-new-WQLJOXSS.js");
+          const { createAgent } = await import("./agents-new-M325HGWT.js");
           return createAgent(this.ctx);
         }
         case "/feedback": {
-          const { feedback } = await import("./feedback-3THCLEBE.js");
+          const { feedback } = await import("./feedback-YGSYBQEW.js");
           return feedback(this.ctx);
         }
         case "/resume": {
@@ -9794,40 +10114,56 @@ var SlashCommandHandler = class {
           return null;
         }
         case "/status": {
-          const { status } = await import("./status-SLYYTKXD.js");
+          const { status } = await import("./status-6FY6RKIS.js");
           return status(this.ctx);
         }
         case "/login": {
-          const { login } = await import("./login-QJROML5I.js");
+          const { login } = await import("./login-XUVEFKCR.js");
           return login({ config: this.ctx.config });
         }
         case "/logout": {
-          const { logout } = await import("./logout-RJ5OAXRI.js");
+          const { logout } = await import("./logout-75YLPOBK.js");
           return logout({ config: this.ctx.config });
         }
         case "/permissions": {
-          const { permissions } = await import("./permissions-CYW62ZK3.js");
+          const { permissions } = await import("./permissions-3GS4ZWVA.js");
           return permissions({ permissionManager: this.ctx.permissionManager });
         }
         case "/skills": {
-          const { skills } = await import("./skills-HF4SAF5O.js");
+          const { skills } = await import("./skills-3M26KASS.js");
           if (!this.ctx.skillsRegistry) {
-            console.log(chalk7.yellow("Skills registry not available."));
-            return null;
+            return "Skills registry not available.";
           }
-          return skills({ skillsRegistry: this.ctx.skillsRegistry }, args);
+          return skills({
+            skillsRegistry: this.ctx.skillsRegistry,
+            workspaceRoot: this.ctx.workspaceRoot
+          }, args);
+        }
+        case "/skills install": {
+          const { skillsInstall } = await import("./skills-install-WJ2LDRQG.js");
+          if (!this.ctx.skillsRegistry) {
+            return "Skills registry not available.";
+          }
+          const skillName = args.join(" ").trim() || void 0;
+          return skillsInstall({
+            skillsRegistry: this.ctx.skillsRegistry,
+            workspaceRoot: this.ctx.workspaceRoot
+          }, skillName);
         }
         case "/skills new":
         case "/skills-new": {
-          const { createSkill } = await import("./skills-new-QDTNEG3R.js");
+          const { createSkill } = await import("./skills-new-KIBUN63X.js");
           if (!this.ctx.skillsRegistry) {
-            console.log(chalk7.yellow("Skills registry not available."));
-            return null;
+            return "Skills registry not available.";
           }
-          return createSkill({ llm: this.ctx.llm, skillsRegistry: this.ctx.skillsRegistry });
+          return createSkill({
+            llm: this.ctx.llm,
+            skillsRegistry: this.ctx.skillsRegistry,
+            workspaceRoot: this.ctx.workspaceRoot
+          });
         }
         case "/theme": {
-          const { theme } = await import("./theme-THMQ5AIN.js");
+          const { theme } = await import("./theme-XNZ2X6HE.js");
           if (!this.ctx.config) {
             console.log(chalk7.yellow("Config not available for theme selection."));
             return null;
@@ -11270,8 +11606,18 @@ var FeedbackManager = class {
     console.log(chalk10.gray("  Help us improve Autohand (takes 10 seconds)"));
     console.log(chalk10.cyan("\u2501".repeat(50)));
     console.log();
+    const safePrompt = async (config) => {
+      try {
+        return await Enquirer.prompt(config);
+      } catch (error) {
+        if (error?.code === "ERR_USE_AFTER_CLOSE") {
+          return null;
+        }
+        throw error;
+      }
+    };
     try {
-      const npsResult = await Enquirer.prompt({
+      const npsResult = await safePrompt({
         type: "select",
         name: "score",
         message: "How would you rate your experience?",
@@ -11284,6 +11630,11 @@ var FeedbackManager = class {
           { name: "skip", message: `${chalk10.gray("Skip")}` }
         ]
       });
+      if (!npsResult) {
+        this.state.dismissed++;
+        this.saveState();
+        return false;
+      }
       if (npsResult.score === "skip") {
         this.state.dismissed++;
         this.saveState();
@@ -11295,26 +11646,28 @@ var FeedbackManager = class {
       let improvement;
       let recommend;
       if (npsScore >= 4) {
-        const followUp = await Enquirer.prompt({
+        const followUp = await safePrompt({
           type: "input",
           name: "reason",
           message: "What do you like most about Autohand? (optional, press Enter to skip)"
         });
-        reason = followUp.reason || void 0;
-        const recResult = await Enquirer.prompt({
-          type: "confirm",
-          name: "recommend",
-          message: "Would you recommend Autohand to a colleague?",
-          initial: true
-        });
-        recommend = recResult.recommend;
+        reason = followUp?.reason || void 0;
+        if (followUp) {
+          const recResult = await safePrompt({
+            type: "confirm",
+            name: "recommend",
+            message: "Would you recommend Autohand to a colleague?",
+            initial: true
+          });
+          recommend = recResult?.recommend;
+        }
       } else {
-        const followUp = await Enquirer.prompt({
+        const followUp = await safePrompt({
           type: "input",
           name: "improvement",
           message: "What could we do better? (optional, press Enter to skip)"
         });
-        improvement = followUp.improvement || void 0;
+        improvement = followUp?.improvement || void 0;
       }
       const response = {
         npsScore,
@@ -11341,6 +11694,9 @@ var FeedbackManager = class {
       console.log();
       return true;
     } catch (error) {
+      if (error?.code === "ERR_USE_AFTER_CLOSE") {
+        return false;
+      }
       this.state.dismissed++;
       this.saveState();
       console.log(chalk10.gray("\nFeedback skipped.\n"));
@@ -11840,6 +12196,30 @@ var TelemetryManager = class {
       context: data.context
     });
   }
+  /**
+   * Track a session failure as a bug report with detailed context.
+   * Prefixes the error type with "BUG:" for easy identification.
+   */
+  async trackSessionFailureBug(data) {
+    this.errorsCount++;
+    const sanitizedStack = data.error.stack?.replace(/\/Users\/[^/]+/g, "/Users/***").replace(/\/home\/[^/]+/g, "/home/***").replace(/C:\\Users\\[^\\]+/g, "C:\\Users\\***");
+    const bugData = {
+      type: "BUG:session_failure",
+      errorMessage: data.error.message,
+      errorName: data.error.name,
+      stack: sanitizedStack,
+      retryAttempt: data.retryAttempt,
+      maxRetries: data.maxRetries,
+      conversationLength: data.conversationLength,
+      lastToolCalls: data.lastToolCalls,
+      iterationCount: data.iterationCount,
+      contextUsage: data.contextUsage,
+      model: data.model || this.currentModel || void 0,
+      provider: data.provider || this.currentProvider || void 0,
+      isRetrying: data.retryAttempt < data.maxRetries
+    };
+    await this.trackEvent("session_failure_bug", bugData);
+  }
   /**
    * Track slash command usage
    */
@@ -11959,462 +12339,9 @@ var TelemetryManager = class {
   }
 };
 
-// src/skills/SkillsRegistry.ts
-import fs18 from "fs-extra";
-import path17 from "path";
-
-// src/skills/SkillParser.ts
-import fs17 from "fs-extra";
-import YAML from "yaml";
-var SkillParser = class {
-  /**
-   * Parse a SKILL.md file from disk
-   */
-  async parseFile(filePath, source) {
-    try {
-      const content = await fs17.readFile(filePath, "utf-8");
-      return this.parseContent(content, filePath, source);
-    } catch (error) {
-      return {
-        success: false,
-        error: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
-  }
-  /**
-   * Parse SKILL.md content directly from a string
-   */
-  parseContent(content, filePath, source) {
-    const extraction = this.extractFrontmatter(content);
-    if (!extraction) {
-      return {
-        success: false,
-        error: "No valid YAML frontmatter found. SKILL.md must start with --- delimited frontmatter."
-      };
-    }
-    try {
-      const parsed = YAML.parse(extraction.frontmatter);
-      const validation = validateSkillFrontmatter(parsed);
-      if (!validation.valid) {
-        return {
-          success: false,
-          error: `Invalid skill frontmatter: ${validation.errors.join("; ")}`
-        };
-      }
-      const skill = {
-        name: parsed.name,
-        description: parsed.description,
-        license: parsed.license,
-        compatibility: parsed.compatibility,
-        metadata: parsed.metadata,
-        "allowed-tools": parsed["allowed-tools"],
-        body: extraction.body,
-        path: filePath,
-        source,
-        isActive: false
-      };
-      return { success: true, skill };
-    } catch (error) {
-      return {
-        success: false,
-        error: `Failed to parse YAML frontmatter: ${error instanceof Error ? error.message : String(error)}`
-      };
-    }
-  }
-  /**
-   * Extract YAML frontmatter and body from content
-   * Frontmatter must be delimited by --- at start and end
-   */
-  extractFrontmatter(content) {
-    if (!content.startsWith("---")) {
-      return null;
-    }
-    const lines = content.split("\n");
-    let closingIndex = -1;
-    for (let i = 1; i < lines.length; i++) {
-      if (lines[i].trim() === "---") {
-        closingIndex = i;
-        break;
-      }
-    }
-    if (closingIndex === -1) {
-      return null;
-    }
-    const frontmatter = lines.slice(1, closingIndex).join("\n");
-    const body = lines.slice(closingIndex + 1).join("\n").trim();
-    return { frontmatter, body };
-  }
-};
-
-// src/skills/SkillsRegistry.ts
-var SIMILARITY_THRESHOLD2 = 0.3;
-var VENDOR_SOURCES = ["codex-user", "claude-user", "codex-project", "claude-project"];
-var SkillsRegistry = class {
-  constructor(userSkillsDir, defaultSource = "autohand-user") {
-    this.userSkillsDir = userSkillsDir;
-    this.skills = /* @__PURE__ */ new Map();
-    this.parser = new SkillParser();
-    this.workspaceRoot = null;
-    this.telemetryManager = null;
-    this.communityClient = null;
-    this.defaultSource = defaultSource;
-  }
-  /**
-   * Set the telemetry manager for tracking skill events
-   */
-  setTelemetryManager(telemetryManager) {
-    this.telemetryManager = telemetryManager;
-  }
-  /**
-   * Set the community skills client for backup/sync operations
-   */
-  setCommunityClient(client) {
-    this.communityClient = client;
-  }
-  /**
-   * Get the community skills client
-   */
-  getCommunityClient() {
-    return this.communityClient;
-  }
-  /**
-   * Check if any vendor skills (codex/claude) are loaded
-   */
-  hasVendorSkills() {
-    for (const skill of this.skills.values()) {
-      if (VENDOR_SOURCES.includes(skill.source)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Get all vendor skills (from codex/claude sources)
-   */
-  getVendorSkills() {
-    return Array.from(this.skills.values()).filter(
-      (skill) => VENDOR_SOURCES.includes(skill.source)
-    );
-  }
-  /**
-   * Import a community skill package and save to disk
-   */
-  async importCommunitySkill(pkg, targetDir) {
-    if (!pkg.name || !pkg.body) {
-      return { success: false, error: "Invalid skill package: missing name or body" };
-    }
-    const skillDir = path17.join(targetDir, pkg.name);
-    const skillPath = path17.join(skillDir, "SKILL.md");
-    if (await fs18.pathExists(skillPath)) {
-      return { success: false, skipped: true, error: "Skill already exists" };
-    }
-    try {
-      await fs18.ensureDir(skillDir);
-      await fs18.writeFile(skillPath, pkg.body, "utf-8");
-      const result = await this.parser.parseFile(skillPath, "community");
-      if (result.success && result.skill) {
-        this.skills.set(result.skill.name, result.skill);
-        return { success: true, path: skillPath };
-      }
-      return { success: false, error: "Failed to parse imported skill" };
-    } catch (err) {
-      const error = err instanceof Error ? err.message : "Unknown error";
-      return { success: false, error };
-    }
-  }
-  /**
-   * Initialize the registry by loading skills from the user directory
-   */
-  async initialize() {
-    await this.loadFromDirectory(this.userSkillsDir, this.defaultSource, true);
-  }
-  /**
-   * Set the workspace root and load project-level skills
-   */
-  async setWorkspace(workspaceRoot) {
-    this.workspaceRoot = workspaceRoot;
-    const claudeProjectSkillsDir = path17.join(workspaceRoot, ".claude", "skills");
-    await this.loadFromDirectory(claudeProjectSkillsDir, "claude-project", false);
-    const autohandProjectSkillsDir = path17.join(workspaceRoot, PROJECT_DIR_NAME, "skills");
-    await this.loadFromDirectory(autohandProjectSkillsDir, "autohand-project", true);
-  }
-  /**
-   * Add an additional skill location to search
-   */
-  async addLocation(directory, source, recursive = true) {
-    await this.loadFromDirectory(directory, source, recursive);
-  }
-  /**
-   * Add a skill location with auto-copy to autohand location
-   * Copies discovered skills to the target autohand directory, preserving structure
-   */
-  async addLocationWithAutoCopy(sourceDirectory, source, targetAutohandDir, recursive = true) {
-    const result = {
-      copiedCount: 0,
-      skippedCount: 0,
-      errorCount: 0,
-      copiedSkills: [],
-      skippedSkills: []
-    };
-    if (!await fs18.pathExists(sourceDirectory)) {
-      return result;
-    }
-    const skillFiles = await this.findSkillFiles(sourceDirectory, recursive);
-    for (const skillPath of skillFiles) {
-      const parseResult = await this.parser.parseFile(skillPath, source);
-      if (!parseResult.success || !parseResult.skill) {
-        continue;
-      }
-      const skill = parseResult.skill;
-      const skillName = skill.name;
-      const skillDir = path17.dirname(skillPath);
-      const relativePath = path17.relative(sourceDirectory, skillDir);
-      const targetSkillDir = path17.join(targetAutohandDir, relativePath);
-      const targetSkillPath = path17.join(targetSkillDir, "SKILL.md");
-      if (await fs18.pathExists(targetSkillPath)) {
-        result.skippedCount++;
-        result.skippedSkills.push(skillName);
-      } else {
-        try {
-          await fs18.ensureDir(targetSkillDir);
-          await fs18.copyFile(skillPath, targetSkillPath);
-          result.copiedCount++;
-          result.copiedSkills.push(skillName);
-        } catch {
-          result.errorCount++;
-        }
-      }
-      this.skills.set(skill.name, skill);
-    }
-    return result;
-  }
-  /**
-   * Set workspace with auto-copy from claude-project to autohand-project
-   */
-  async setWorkspaceWithAutoCopy(workspaceRoot) {
-    this.workspaceRoot = workspaceRoot;
-    const claudeProjectSkillsDir = path17.join(workspaceRoot, ".claude", "skills");
-    const autohandProjectSkillsDir = path17.join(workspaceRoot, PROJECT_DIR_NAME, "skills");
-    await this.addLocationWithAutoCopy(
-      claudeProjectSkillsDir,
-      "claude-project",
-      autohandProjectSkillsDir,
-      false
-      // Claude project is not recursive
-    );
-    await this.loadFromDirectory(autohandProjectSkillsDir, "autohand-project", true);
-  }
-  /**
-   * Add a skill location with auto-copy AND backup to community API
-   * Enhanced version that also backs up vendor skills to the API
-   */
-  async addLocationWithAutoCopyAndBackup(sourceDirectory, source, targetAutohandDir, recursive = true) {
-    const result = await this.addLocationWithAutoCopy(
-      sourceDirectory,
-      source,
-      targetAutohandDir,
-      recursive
-    );
-    if (this.communityClient && result.copiedCount > 0) {
-      const backupPayloads = [];
-      for (const skillName of result.copiedSkills) {
-        const skill = this.skills.get(skillName);
-        if (skill) {
-          backupPayloads.push({
-            name: skill.name,
-            description: skill.description,
-            body: skill.body,
-            allowedTools: skill["allowed-tools"],
-            originalSource: source,
-            originalPath: skill.path
-          });
-        }
-      }
-      if (backupPayloads.length > 0) {
-        await this.communityClient.backupAllSkills(backupPayloads);
-      }
-    }
-    return result;
-  }
-  /**
-   * Backup all vendor skills to community API
-   */
-  async backupAllVendorSkills() {
-    if (!this.communityClient) {
-      return { backed: 0, failed: 0 };
-    }
-    const vendorSkills = this.getVendorSkills();
-    if (vendorSkills.length === 0) {
-      return { backed: 0, failed: 0 };
-    }
-    const payloads = vendorSkills.map((skill) => ({
-      name: skill.name,
-      description: skill.description,
-      body: skill.body,
-      allowedTools: skill["allowed-tools"],
-      originalSource: skill.source,
-      originalPath: skill.path
-    }));
-    return this.communityClient.backupAllSkills(payloads);
-  }
-  /**
-   * Load skills from a directory
-   */
-  async loadFromDirectory(directory, source, recursive) {
-    if (!await fs18.pathExists(directory)) {
-      return;
-    }
-    const skillFiles = await this.findSkillFiles(directory, recursive);
-    for (const skillPath of skillFiles) {
-      const result = await this.parser.parseFile(skillPath, source);
-      if (result.success && result.skill) {
-        this.skills.set(result.skill.name, result.skill);
-      }
-    }
-  }
-  /**
-   * Find all SKILL.md files in a directory
-   */
-  async findSkillFiles(directory, recursive) {
-    const results = [];
-    if (!await fs18.pathExists(directory)) {
-      return results;
-    }
-    const entries = await fs18.readdir(directory, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = path17.join(directory, entry.name);
-      if (entry.isDirectory()) {
-        const skillPath = path17.join(fullPath, "SKILL.md");
-        if (await fs18.pathExists(skillPath)) {
-          results.push(skillPath);
-        }
-        if (recursive) {
-          const nested = await this.findSkillFiles(fullPath, true);
-          results.push(...nested);
-        }
-      }
-    }
-    return results;
-  }
-  /**
-   * List all available skills
-   */
-  listSkills() {
-    return Array.from(this.skills.values());
-  }
-  /**
-   * Get a specific skill by name
-   */
-  getSkill(name) {
-    return this.skills.get(name) ?? null;
-  }
-  /**
-   * Activate a skill by name
-   */
-  activateSkill(name) {
-    const skill = this.skills.get(name);
-    if (!skill) {
-      return false;
-    }
-    skill.isActive = true;
-    return true;
-  }
-  /**
-   * Deactivate a skill by name
-   */
-  deactivateSkill(name) {
-    const skill = this.skills.get(name);
-    if (!skill) {
-      return false;
-    }
-    skill.isActive = false;
-    return true;
-  }
-  /**
-   * Deactivate all active skills
-   */
-  deactivateAll() {
-    for (const skill of this.skills.values()) {
-      skill.isActive = false;
-    }
-  }
-  /**
-   * Get all currently active skills
-   */
-  getActiveSkills() {
-    return Array.from(this.skills.values()).filter((s) => s.isActive);
-  }
-  /**
-   * Find skills similar to a given query using Jaccard similarity
-   */
-  findSimilar(query, threshold = SIMILARITY_THRESHOLD2) {
-    const queryTokens = this.tokenize(query);
-    const matches = [];
-    for (const skill of this.skills.values()) {
-      const skillText = `${skill.name} ${skill.description}`;
-      const skillTokens = this.tokenize(skillText);
-      const score = this.calculateJaccard(queryTokens, skillTokens);
-      if (score >= threshold) {
-        matches.push({ skill, score });
-      }
-    }
-    return matches.sort((a, b) => b.score - a.score);
-  }
-  /**
-   * Calculate Jaccard similarity between two token sets
-   */
-  calculateJaccard(a, b) {
-    if (a.size === 0 || b.size === 0) {
-      return 0;
-    }
-    const intersection = new Set([...a].filter((x) => b.has(x)));
-    const union = /* @__PURE__ */ new Set([...a, ...b]);
-    return intersection.size / union.size;
-  }
-  /**
-   * Tokenize text into a set of lowercase words
-   */
-  tokenize(text) {
-    return new Set(
-      text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 2)
-    );
-  }
-  /**
-   * Get the number of loaded skills
-   */
-  get size() {
-    return this.skills.size;
-  }
-  /**
-   * Check if a skill exists by name
-   */
-  hasSkill(name) {
-    return this.skills.has(name);
-  }
-  /**
-   * Save a new skill to the user skills directory
-   */
-  async saveSkill(name, content) {
-    const skillDir = path17.join(this.userSkillsDir, name);
-    const skillPath = path17.join(skillDir, "SKILL.md");
-    try {
-      await fs18.ensureDir(skillDir);
-      await fs18.writeFile(skillPath, content, "utf-8");
-      const result = await this.parser.parseFile(skillPath, "autohand-user");
-      if (result.success && result.skill) {
-        this.skills.set(result.skill.name, result.skill);
-        return true;
-      }
-      return false;
-    } catch {
-      return false;
-    }
-  }
-};
-
 // src/skills/CommunitySkillsClient.ts
-import fs19 from "fs-extra";
-import path18 from "path";
+import fs17 from "fs-extra";
+import path17 from "path";
 var CommunitySkillsClient = class {
   constructor(config) {
     this.queue = [];
@@ -12422,7 +12349,7 @@ var CommunitySkillsClient = class {
     this.apiBaseUrl = config.apiBaseUrl.replace(/\/$/, "");
     this.enabled = config.enabled;
     this.deviceId = config.deviceId || this.loadDeviceId();
-    this.queueDir = config.queueDir || path18.join(AUTOHAND_HOME, "community-skills");
+    this.queueDir = config.queueDir || path17.join(AUTOHAND_HOME, "community-skills");
     this.timeout = config.timeout || 1e4;
     this.maxRetries = config.maxRetries || 3;
   }
@@ -12430,10 +12357,10 @@ var CommunitySkillsClient = class {
    * Load device ID from filesystem
    */
   loadDeviceId() {
-    const deviceIdPath = path18.join(AUTOHAND_HOME, "device-id");
+    const deviceIdPath = path17.join(AUTOHAND_HOME, "device-id");
     try {
-      if (fs19.existsSync(deviceIdPath)) {
-        return fs19.readFileSync(deviceIdPath, "utf-8").trim();
+      if (fs17.existsSync(deviceIdPath)) {
+        return fs17.readFileSync(deviceIdPath, "utf-8").trim();
       }
     } catch {
     }
@@ -12445,10 +12372,10 @@ var CommunitySkillsClient = class {
   loadQueue() {
     if (this.queueLoaded) return;
     this.queueLoaded = true;
-    const queuePath = path18.join(this.queueDir, "queue.json");
+    const queuePath = path17.join(this.queueDir, "queue.json");
     try {
-      if (fs19.existsSync(queuePath)) {
-        this.queue = fs19.readJsonSync(queuePath);
+      if (fs17.existsSync(queuePath)) {
+        this.queue = fs17.readJsonSync(queuePath);
       }
     } catch {
       this.queue = [];
@@ -12459,8 +12386,8 @@ var CommunitySkillsClient = class {
    */
   saveQueue() {
     try {
-      fs19.ensureDirSync(this.queueDir);
-      fs19.writeJsonSync(path18.join(this.queueDir, "queue.json"), this.queue);
+      fs17.ensureDirSync(this.queueDir);
+      fs17.writeJsonSync(path17.join(this.queueDir, "queue.json"), this.queue);
     } catch {
     }
   }
@@ -13137,7 +13064,7 @@ function createPersistentInput(options) {
 }
 
 // src/ui/toolOutput.ts
-import * as path19 from "path";
+import * as path18 from "path";
 var FILE_SUMMARY_TOOLS = /* @__PURE__ */ new Set([
   "read_file",
   "write_file",
@@ -13177,9 +13104,9 @@ ${truncatedContent}` : outputLines > 0 ? `
     };
   }
   if (FILE_SUMMARY_TOOLS.has(tool) && filePath) {
-    const fileName = path19.basename(filePath);
-    const dirName = path19.dirname(filePath);
-    const displayPath = dirName === "." ? fileName : `${path19.basename(dirName)}/${fileName}`;
+    const fileName = path18.basename(filePath);
+    const dirName = path18.dirname(filePath);
+    const displayPath = dirName === "." ? fileName : `${path18.basename(dirName)}/${fileName}`;
     const lines = countLines(content);
     const size = formatFileSize(Buffer.byteLength(content, "utf8"));
     return {
@@ -14081,7 +14008,7 @@ var IntentDetector = class {
 };
 
 // src/core/EnvironmentBootstrap.ts
-import fs20 from "fs-extra";
+import fs18 from "fs-extra";
 import { join as join2 } from "path";
 import { exec } from "child_process";
 import { promisify } from "util";
@@ -14177,14 +14104,14 @@ var EnvironmentBootstrap = class {
    */
   async detectPackageManager(root) {
     for (const { file, pm } of this.lockfileChecks) {
-      if (await fs20.pathExists(join2(root, file))) {
+      if (await fs18.pathExists(join2(root, file))) {
         return pm;
       }
     }
     const pkgPath = join2(root, "package.json");
-    if (await fs20.pathExists(pkgPath)) {
+    if (await fs18.pathExists(pkgPath)) {
       try {
-        const pkg = await fs20.readJson(pkgPath);
+        const pkg = await fs18.readJson(pkgPath);
         if (pkg.packageManager) {
           const match = pkg.packageManager.match(/^(bun|pnpm|yarn|npm)@/);
           if (match) {
@@ -14215,7 +14142,7 @@ var EnvironmentBootstrap = class {
     const step = { name: "Git Sync", status: "running" };
     const start = Date.now();
     try {
-      const isGit = await fs20.pathExists(join2(root, ".git"));
+      const isGit = await fs18.pathExists(join2(root, ".git"));
       if (!isGit) {
         return {
           ...step,
@@ -14296,18 +14223,18 @@ var EnvironmentBootstrap = class {
     const details = [];
     try {
       const nvmrcPath = join2(root, ".nvmrc");
-      const nvmrcExists = await fs20.pathExists(nvmrcPath);
+      const nvmrcExists = await fs18.pathExists(nvmrcPath);
       const nodeVersionPath = join2(root, ".node-version");
-      const nodeVersionExists = await fs20.pathExists(nodeVersionPath);
+      const nodeVersionExists = await fs18.pathExists(nodeVersionPath);
       if (nvmrcExists || nodeVersionExists) {
         details.push("Node version file found");
       }
       const toolVersionsPath = join2(root, ".tool-versions");
-      if (await fs20.pathExists(toolVersionsPath)) {
+      if (await fs18.pathExists(toolVersionsPath)) {
         details.push(".tool-versions found");
       }
       const rustToolchainPath = join2(root, "rust-toolchain.toml");
-      if (await fs20.pathExists(rustToolchainPath)) {
+      if (await fs18.pathExists(rustToolchainPath)) {
         details.push("Rust toolchain found");
       }
       step.status = "success";
@@ -14384,7 +14311,7 @@ var EnvironmentBootstrap = class {
 };
 
 // src/core/CodeQualityPipeline.ts
-import fs21 from "fs-extra";
+import fs19 from "fs-extra";
 import { join as join3 } from "path";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
@@ -14454,11 +14381,11 @@ var CodeQualityPipeline = class {
    */
   async detectScripts(root) {
     const pkgPath = join3(root, "package.json");
-    if (!await fs21.pathExists(pkgPath)) {
+    if (!await fs19.pathExists(pkgPath)) {
       return {};
     }
     try {
-      const pkg = await fs21.readJson(pkgPath);
+      const pkg = await fs19.readJson(pkgPath);
       const scripts = pkg.scripts || {};
       return {
         lint: this.findScript(scripts, this.scriptPatterns.lint),
@@ -14644,6 +14571,7 @@ var AutohandAgent = class {
     this.lastIntent = "diagnostic";
     this.filesModifiedThisSession = false;
     this.searchQueries = [];
+    this.sessionRetryCount = 0;
     const initialProvider = runtime.config.provider ?? "openrouter";
     const providerSettings = getProviderConfig(runtime.config, initialProvider);
     const model = runtime.options.model ?? providerSettings?.model ?? "unconfigured";
@@ -14670,7 +14598,7 @@ var AutohandAgent = class {
       runtime,
       files,
       resolveWorkspacePath: (relativePath) => this.resolveWorkspacePath(relativePath),
-      confirmDangerousAction: (message) => this.confirmDangerousAction(message),
+      confirmDangerousAction: (message, context) => this.confirmDangerousAction(message, context),
       onExploration: (entry) => this.recordExploration(entry),
       onToolOutput: (chunk) => this.handleToolOutput(chunk),
       toolsRegistry: this.toolsRegistry,
@@ -14762,7 +14690,7 @@ var AutohandAgent = class {
           throw error;
         }
       },
-      confirmApproval: (message) => this.confirmDangerousAction(message),
+      confirmApproval: (message, context) => this.confirmDangerousAction(message, context),
       definitions: [...DEFAULT_TOOL_DEFINITIONS, ...delegationTools],
       clientContext
     });
@@ -15111,7 +15039,16 @@ var AutohandAgent = class {
       return false;
     };
     if (normalized.startsWith("/") && !looksLikeFilePath(normalized)) {
-      const handled = await this.slashHandler.handle(normalized);
+      const parts = normalized.split(/\s+/);
+      let command = parts[0];
+      let args = parts.slice(1);
+      const twoWordCommands = ["/skills new", "/agents new"];
+      const potentialTwoWord = `${parts[0]} ${parts[1] || ""}`.trim();
+      if (twoWordCommands.includes(potentialTwoWord)) {
+        command = potentialTwoWord;
+        args = parts.slice(2);
+      }
+      const handled = await this.slashHandler.handle(command, args);
       if (handled === null) {
         return null;
       }
@@ -15171,7 +15108,7 @@ var AutohandAgent = class {
     }
   }
   async listWorkspaceFiles() {
-    const entries = await fs22.readdir(this.runtime.workspaceRoot);
+    const entries = await fs20.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"));
@@ -15198,18 +15135,18 @@ var AutohandAgent = class {
   async walkWorkspace(current, acc) {
     let entries;
     try {
-      entries = await fs22.readdir(current);
+      entries = await fs20.readdir(current);
     } catch {
       return;
     }
     for (const entry of entries) {
-      const full = path20.join(current, entry);
-      const rel = path20.relative(this.runtime.workspaceRoot, full);
+      const full = path19.join(current, entry);
+      const rel = path19.relative(this.runtime.workspaceRoot, full);
       if (rel === "" || this.shouldSkipPath(rel) || this.ignoreFilter.isIgnored(rel)) {
         continue;
       }
       try {
-        const stats = await fs22.stat(full);
+        const stats = await fs20.stat(full);
         if (stats.isDirectory()) {
           await this.walkWorkspace(full, acc);
         } else if (stats.isFile()) {
@@ -15579,8 +15516,8 @@ ${selectedProvider} is not configured yet. Let's set it up!
     );
   }
   async createAgentsFile() {
-    const target = path20.join(this.runtime.workspaceRoot, "AGENTS.md");
-    if (await fs22.pathExists(target)) {
+    const target = path19.join(this.runtime.workspaceRoot, "AGENTS.md");
+    if (await fs20.pathExists(target)) {
       console.log(chalk13.gray("AGENTS.md already exists in this workspace."));
       return;
     }
@@ -15588,7 +15525,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 fs22.writeFile(target, template, "utf8");
+    await fs20.writeFile(target, template, "utf8");
     console.log(chalk13.green("Created AGENTS.md template. Customize it to guide the agent."));
   }
   /**
@@ -15700,6 +15637,33 @@ No provider is configured yet. Let's set one up!
         await this.promptModelSelection();
         return this.runInstruction(instruction);
       }
+      const err = error instanceof Error ? error : new Error(String(error));
+      const maxRetries = this.runtime.config.agent?.sessionRetryLimit ?? 3;
+      const baseDelay = this.runtime.config.agent?.sessionRetryDelay ?? 1e3;
+      if (this.isRetryableSessionError(err) && this.sessionRetryCount < maxRetries) {
+        this.sessionRetryCount++;
+        await this.submitSessionFailureBugReport(err, this.sessionRetryCount, maxRetries);
+        console.log(chalk13.yellow(`
+\u26A0 Session encountered an error: ${err.message}`));
+        console.log(chalk13.cyan(`  Attempting recovery (${this.sessionRetryCount}/${maxRetries})...`));
+        const delay = baseDelay * Math.pow(1.5, this.sessionRetryCount - 1);
+        await this.sleep(delay);
+        this.injectContinuationMessage(err, this.sessionRetryCount);
+        try {
+          this.setUIStatus("Recovering session...");
+          await this.runReactLoop(abortController);
+          this.sessionRetryCount = 0;
+          success = true;
+          return success;
+        } catch (retryError) {
+          if (this.sessionRetryCount >= maxRetries) {
+            this.sessionRetryCount = 0;
+          } else {
+            throw retryError;
+          }
+        }
+      }
+      this.sessionRetryCount = 0;
       this.stopUI(true, "Session failed");
       const errorMessage = error instanceof Error ? error.message : String(error);
       this.emitOutput({ type: "error", content: errorMessage });
@@ -16298,7 +16262,8 @@ ${summary}`
     const needApproval = Boolean(args.need_user_approve);
     if (needApproval) {
       const approved = await this.confirmDangerousAction(
-        `Crop ${direction} ${Math.floor(amount)} message(s) from the conversation?`
+        `Crop ${direction} ${Math.floor(amount)} message(s) from the conversation?`,
+        { tool: "smart_context_cropper" }
       );
       if (!approved) {
         return "smart_context_cropper canceled by user.";
@@ -16672,16 +16637,16 @@ ${toolSignatures}
     return normalizedSeed || null;
   }
   async fileExists(relativePath) {
-    const fullPath = path20.resolve(this.runtime.workspaceRoot, relativePath);
+    const fullPath = path19.resolve(this.runtime.workspaceRoot, relativePath);
     if (!fullPath.startsWith(this.runtime.workspaceRoot)) {
       return false;
     }
-    const exists = await fs22.pathExists(fullPath);
+    const exists = await fs20.pathExists(fullPath);
     if (!exists) {
       return false;
     }
     try {
-      const stats = await fs22.stat(fullPath);
+      const stats = await fs20.stat(fullPath);
       return stats.isFile();
     } catch {
       return false;
@@ -16967,7 +16932,7 @@ ${ctx.contents}`).join("\n\n");
       encoding: "utf8"
     });
     const gitStatus2 = git.status === 0 ? git.stdout.trim() : void 0;
-    const entries = await fs22.readdir(this.runtime.workspaceRoot);
+    const entries = await fs20.readdir(this.runtime.workspaceRoot);
     const recentFiles = entries.filter((entry) => !this.ignoreFilter.isIgnored(entry)).slice(0, 20);
     return {
       workspaceRoot: this.runtime.workspaceRoot,
@@ -16978,17 +16943,17 @@ ${ctx.contents}`).join("\n\n");
   async loadInstructionFiles() {
     const instructions = [];
     const workspace = this.runtime.workspaceRoot;
-    const agentsPath = path20.join(workspace, "AGENTS.md");
-    if (await fs22.pathExists(agentsPath)) {
-      const content = await fs22.readFile(agentsPath, "utf-8");
+    const agentsPath = path19.join(workspace, "AGENTS.md");
+    if (await fs20.pathExists(agentsPath)) {
+      const content = await fs20.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 = path20.join(workspace, providerFile);
-      if (await fs22.pathExists(providerPath)) {
-        const content = await fs22.readFile(providerPath, "utf-8");
+      const providerPath = path19.join(workspace, providerFile);
+      if (await fs20.pathExists(providerPath)) {
+        const content = await fs20.readFile(providerPath, "utf-8");
         instructions.push(`## Provider Instructions (${providerFile})
 ${content}`);
       }
@@ -17139,9 +17104,100 @@ ${parts.join("\n")}`
     return `${tokens} tokens`;
   }
   /**
-   * Display the detected intent mode to the user
+   * Sleep helper for retry delays
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Categorize errors to determine retry behavior.
+   * Returns true if the error is retryable.
+   */
+  isRetryableSessionError(error) {
+    const message = error.message.toLowerCase();
+    if (message.includes("authentication") || message.includes("api key") || message.includes("unauthorized") || message.includes("forbidden") || message.includes("access denied")) {
+      return false;
+    }
+    if (message.includes("payment required") || message.includes("billing") || message.includes("quota exceeded")) {
+      return false;
+    }
+    if (message.includes("model not found") || message.includes("model does not exist")) {
+      return false;
+    }
+    if (message.includes("cancelled") || message.includes("canceled") || message.includes("aborted") || message.includes("user force closed")) {
+      return false;
+    }
+    if (message.includes("payload too large") || message.includes("context too long")) {
+      return false;
+    }
+    if (message.includes("network") || message.includes("connection") || message.includes("econnreset") || message.includes("enotfound") || message.includes("etimedout")) {
+      return true;
+    }
+    if (message.includes("internal error") || message.includes("service unavailable") || message.includes("bad gateway") || message.includes("gateway timeout") || message.includes("overloaded")) {
+      return true;
+    }
+    if (message.includes("rate limit") || message.includes("too many requests")) {
+      return true;
+    }
+    if (message.includes("timed out") || message.includes("timeout")) {
+      return true;
+    }
+    if (message.includes("json") || message.includes("parse") || message.includes("unexpected token")) {
+      return true;
+    }
+    return true;
+  }
+  /**
+   * Inject a continuation message into the conversation to help the LLM
+   * recover from a failure and continue the task.
+   */
+  injectContinuationMessage(error, retryAttempt) {
+    const continuationPrompts = [
+      // First retry: gentle continuation
+      `[System Recovery] An error occurred (${error.message}). Please continue from where you left off. Review the conversation context and proceed with the next logical step. If you were in the middle of a tool call, retry it. If you completed tools, provide your response.`,
+      // Second retry: more explicit
+      `[System Recovery - Attempt ${retryAttempt + 1}] The previous operation encountered an error. Please analyze the current state and continue. Focus on completing the user's original request. If needed, you can re-read files or re-execute commands to verify the current state.`,
+      // Third retry: most explicit with safety
+      `[System Recovery - Final Attempt] Multiple errors have occurred. Please provide a status update to the user. If the task cannot be completed, explain what was accomplished and what remains. Do not attempt complex operations - focus on providing a helpful response.`
+    ];
+    const promptIndex = Math.min(retryAttempt, continuationPrompts.length - 1);
+    const continuationMessage = continuationPrompts[promptIndex];
+    this.conversation.addSystemNote(continuationMessage);
+  }
+  /**
+   * Submit a detailed bug report when a session failure occurs.
+   */
+  async submitSessionFailureBugReport(error, retryAttempt, maxRetries) {
+    try {
+      const history = this.conversation.history();
+      const recentToolCalls = history.filter((m) => m.role === "assistant" && m.tool_calls).slice(-3).flatMap((m) => m.tool_calls?.map((tc) => tc.function?.name) || []).filter(Boolean);
+      const model = this.runtime.options.model ?? getProviderConfig(this.runtime.config, this.activeProvider)?.model;
+      await this.telemetryManager.trackSessionFailureBug({
+        error,
+        retryAttempt,
+        maxRetries,
+        conversationLength: history.length,
+        lastToolCalls: recentToolCalls,
+        iterationCount: this.__currentIteration ?? 0,
+        contextUsage: this.contextPercentLeft,
+        model,
+        provider: this.activeProvider
+      });
+      await this.errorLogger.log(error, {
+        context: `Session failure (retry ${retryAttempt + 1}/${maxRetries})`,
+        workspace: this.runtime.workspaceRoot
+      });
+    } catch (reportError) {
+      console.error(chalk13.gray(`[Debug] Failed to submit bug report: ${reportError.message}`));
+    }
+  }
+  /**
+   * Display the detected intent mode to the user (only in debug mode)
    */
   displayIntentMode(result) {
+    if (process.env.AUTOHAND_DEBUG !== "1") {
+      return;
+    }
     if (result.intent === "diagnostic") {
       console.log(chalk13.blue("[DIAG] Mode: Diagnostic (read-only analysis)"));
       if (result.keywords.length > 0) {
@@ -17161,18 +17217,23 @@ ${parts.join("\n")}`
    * Run environment bootstrap before implementation
    */
   async runEnvironmentBootstrap() {
-    console.log(chalk13.cyan("[BOOTSTRAP] Running environment setup..."));
+    const isDebug = process.env.AUTOHAND_DEBUG === "1";
+    if (isDebug) {
+      console.log(chalk13.cyan("[BOOTSTRAP] Running environment setup..."));
+    }
     const result = await this.environmentBootstrap.run(this.runtime.workspaceRoot);
     for (const step of result.steps) {
       const status = step.status === "success" ? chalk13.green("[OK]") : step.status === "failed" ? chalk13.red("[FAIL]") : step.status === "skipped" ? chalk13.gray("[SKIP]") : chalk13.gray("[...]");
       const duration = step.duration ? chalk13.gray(`(${(step.duration / 1e3).toFixed(1)}s)`) : "";
       const detail = step.detail ? chalk13.gray(` ${step.detail}`) : "";
-      console.log(`  ${status} ${step.name.padEnd(14)} ${duration}${detail}`);
+      if (step.status === "failed" || isDebug) {
+        console.log(`  ${status} ${step.name.padEnd(14)} ${duration}${detail}`);
+      }
       if (step.error) {
         console.log(chalk13.red(`       Error: ${step.error}`));
       }
     }
-    if (result.success) {
+    if (result.success && isDebug) {
       console.log(chalk13.green(`
 [READY] Environment ready (${(result.duration / 1e3).toFixed(1)}s)
 `));
@@ -17218,6 +17279,45 @@ ${parts.join("\n")}`
   getImageManager() {
     return this.imageManager;
   }
+  /**
+   * Handle a slash command (e.g., /skills, /skills install, /model)
+   * Returns the command output or null if the command doesn't exist
+   */
+  async handleSlashCommand(command, args = []) {
+    return this.slashHandler.handle(command, args);
+  }
+  /**
+   * Check if a string is a slash command
+   */
+  isSlashCommand(input) {
+    return input.trim().startsWith("/");
+  }
+  /**
+   * Check if a slash command is supported (exists in the command map)
+   */
+  isSlashCommandSupported(command) {
+    return this.slashHandler.isCommandSupported(command);
+  }
+  /**
+   * Parse a slash command string into command and args
+   * e.g., "/skills install myskill" -> { command: "/skills install", args: ["myskill"] }
+   */
+  parseSlashCommand(input) {
+    const trimmed = input.trim();
+    const parts = trimmed.split(/\s+/);
+    const twoWordCommands = ["/skills install", "/skills new", "/agents new"];
+    const potentialTwoWord = parts.slice(0, 2).join(" ");
+    if (twoWordCommands.includes(potentialTwoWord)) {
+      return {
+        command: potentialTwoWord,
+        args: parts.slice(2)
+      };
+    }
+    return {
+      command: parts[0],
+      args: parts.slice(1)
+    };
+  }
   /**
    * Get messages with images included for the LLM API call.
    * Modifies the last user message to include any images from the session.
@@ -17375,10 +17475,13 @@ ${chalk13.gray("\u203A")} ${inputPreview}${chalk13.gray("\u258B")}`;
     });
     this.activeProvider = provider;
   }
-  async confirmDangerousAction(message) {
+  async confirmDangerousAction(message, context) {
     if (this.runtime.options.yes || this.runtime.config.ui?.autoConfirm) {
       return true;
     }
+    if (this.confirmationCallback) {
+      return this.confirmationCallback(message, context);
+    }
     if (isExternalCallbackEnabled()) {
       return confirm(message);
     }
@@ -17409,7 +17512,7 @@ ${chalk13.gray("\u203A")} ${inputPreview}${chalk13.gray("\u258B")}`;
     }
   }
   resolveWorkspacePath(relativePath) {
-    const resolved = path20.resolve(this.runtime.workspaceRoot, relativePath);
+    const resolved = path19.resolve(this.runtime.workspaceRoot, relativePath);
     if (!resolved.startsWith(this.runtime.workspaceRoot)) {
       throw new Error(`Path ${relativePath} escapes workspace root.`);
     }
@@ -17426,6 +17529,13 @@ ${chalk13.gray("\u203A")} ${inputPreview}${chalk13.gray("\u258B")}`;
   setOutputListener(listener) {
     this.outputListener = listener;
   }
+  /**
+   * Set a callback for confirmation prompts (used by RPC mode)
+   * When set, this callback is used instead of the default enquirer prompt
+   */
+  setConfirmationCallback(callback) {
+    this.confirmationCallback = callback;
+  }
   emitOutput(event) {
     if (this.outputListener) {
       this.outputListener(event);
@@ -17441,15 +17551,16 @@ ${chalk13.gray("\u203A")} ${inputPreview}${chalk13.gray("\u258B")}`;
     return {
       model: this.runtime.options.model ?? providerSettings?.model ?? "unconfigured",
       workspace: this.runtime.workspaceRoot,
-      contextPercent: this.contextPercentLeft
+      contextPercent: this.contextPercentLeft,
+      tokensUsed: this.totalTokensUsed
     };
   }
 };
 
 // src/skills/autoSkill.ts
-import fs23 from "fs-extra";
+import fs21 from "fs-extra";
 import os6 from "os";
-import path21 from "path";
+import path20 from "path";
 import chalk14 from "chalk";
 var AVAILABLE_TOOLS = {
   file: [
@@ -17536,7 +17647,7 @@ var ProjectAnalyzer = class {
    */
   async analyze() {
     const analysis = {
-      projectName: path21.basename(this.projectRoot),
+      projectName: path20.basename(this.projectRoot),
       languages: [],
       frameworks: [],
       patterns: [],
@@ -17548,8 +17659,8 @@ var ProjectAnalyzer = class {
       hasCI: false,
       packageManager: null
     };
-    analysis.hasGit = await fs23.pathExists(path21.join(this.projectRoot, ".git"));
-    analysis.hasCI = await fs23.pathExists(path21.join(this.projectRoot, ".github", "workflows")) || await fs23.pathExists(path21.join(this.projectRoot, ".gitlab-ci.yml")) || await fs23.pathExists(path21.join(this.projectRoot, ".circleci"));
+    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"));
     await this.analyzePackageJson(analysis);
     await this.analyzePython(analysis);
     await this.analyzeRust(analysis);
@@ -17571,12 +17682,12 @@ var ProjectAnalyzer = class {
    * Analyze package.json for Node.js projects
    */
   async analyzePackageJson(analysis) {
-    const packageJsonPath = path21.join(this.projectRoot, "package.json");
-    if (!await fs23.pathExists(packageJsonPath)) {
+    const packageJsonPath = path20.join(this.projectRoot, "package.json");
+    if (!await fs21.pathExists(packageJsonPath)) {
       return;
     }
     try {
-      const pkg = await fs23.readJson(packageJsonPath);
+      const pkg = await fs21.readJson(packageJsonPath);
       analysis.projectName = pkg.name || analysis.projectName;
       const allDeps = {
         ...pkg.dependencies,
@@ -17584,13 +17695,13 @@ var ProjectAnalyzer = class {
       };
       const depNames = Object.keys(allDeps);
       analysis.dependencies.push(...depNames);
-      if (await fs23.pathExists(path21.join(this.projectRoot, "bun.lockb"))) {
+      if (await fs21.pathExists(path20.join(this.projectRoot, "bun.lockb"))) {
         analysis.packageManager = "bun";
-      } else if (await fs23.pathExists(path21.join(this.projectRoot, "pnpm-lock.yaml"))) {
+      } else if (await fs21.pathExists(path20.join(this.projectRoot, "pnpm-lock.yaml"))) {
         analysis.packageManager = "pnpm";
-      } else if (await fs23.pathExists(path21.join(this.projectRoot, "yarn.lock"))) {
+      } else if (await fs21.pathExists(path20.join(this.projectRoot, "yarn.lock"))) {
         analysis.packageManager = "yarn";
-      } else if (await fs23.pathExists(path21.join(this.projectRoot, "package-lock.json"))) {
+      } else if (await fs21.pathExists(path20.join(this.projectRoot, "package-lock.json"))) {
         analysis.packageManager = "npm";
       }
       if (allDeps.typescript) {
@@ -17631,14 +17742,14 @@ var ProjectAnalyzer = class {
    * Analyze Python project files
    */
   async analyzePython(analysis) {
-    const requirementsPath = path21.join(this.projectRoot, "requirements.txt");
-    const pyprojectPath = path21.join(this.projectRoot, "pyproject.toml");
+    const requirementsPath = path20.join(this.projectRoot, "requirements.txt");
+    const pyprojectPath = path20.join(this.projectRoot, "pyproject.toml");
     let hasPython = false;
-    if (await fs23.pathExists(requirementsPath)) {
+    if (await fs21.pathExists(requirementsPath)) {
       hasPython = true;
       analysis.packageManager = "pip";
       try {
-        const content = await fs23.readFile(requirementsPath, "utf-8");
+        const content = await fs21.readFile(requirementsPath, "utf-8");
         const lines = content.toLowerCase();
         for (const [framework, deps] of Object.entries(PYTHON_FRAMEWORKS)) {
           if (deps.some((d) => lines.includes(d))) {
@@ -17652,7 +17763,7 @@ var ProjectAnalyzer = class {
       } catch {
       }
     }
-    if (await fs23.pathExists(pyprojectPath)) {
+    if (await fs21.pathExists(pyprojectPath)) {
       hasPython = true;
     }
     if (hasPython) {
@@ -17663,8 +17774,8 @@ var ProjectAnalyzer = class {
    * Analyze Rust project
    */
   async analyzeRust(analysis) {
-    const cargoPath = path21.join(this.projectRoot, "Cargo.toml");
-    if (await fs23.pathExists(cargoPath)) {
+    const cargoPath = path20.join(this.projectRoot, "Cargo.toml");
+    if (await fs21.pathExists(cargoPath)) {
       analysis.languages.push("rust");
       analysis.packageManager = "cargo";
     }
@@ -17673,8 +17784,8 @@ var ProjectAnalyzer = class {
    * Analyze Go project
    */
   async analyzeGo(analysis) {
-    const goModPath = path21.join(this.projectRoot, "go.mod");
-    if (await fs23.pathExists(goModPath)) {
+    const goModPath = path20.join(this.projectRoot, "go.mod");
+    if (await fs21.pathExists(goModPath)) {
       analysis.languages.push("go");
       analysis.packageManager = "go";
     }
@@ -17683,7 +17794,7 @@ var ProjectAnalyzer = class {
    * Detect additional project patterns
    */
   async detectPatterns(analysis) {
-    if (await fs23.pathExists(path21.join(this.projectRoot, "Dockerfile"))) {
+    if (await fs21.pathExists(path20.join(this.projectRoot, "Dockerfile"))) {
       analysis.patterns.push("docker");
     }
     const dbFiles = await this.findFiles("**/migrations/**", 2);
@@ -17702,13 +17813,13 @@ var ProjectAnalyzer = class {
     async function walk(dir, depth) {
       if (depth > maxDepth) return;
       try {
-        const entries = await fs23.readdir(dir, { withFileTypes: true });
+        const entries = await fs21.readdir(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = path21.join(dir, entry.name);
+          const fullPath = path20.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 = path21.extname(entry.name);
+            const ext = path20.extname(entry.name);
             if (pattern === "*.js" && ext === ".js") {
               results.push(fullPath);
             } else if (pattern === "*.ts" && ext === ".ts") {
@@ -17853,10 +17964,10 @@ async function generateAutoSkills(analysis, llm) {
   }
 }
 async function saveSkill(skill, skillsDir) {
-  const skillDir = path21.join(skillsDir, skill.name);
-  const skillPath = path21.join(skillDir, "SKILL.md");
+  const skillDir = path20.join(skillsDir, skill.name);
+  const skillPath = path20.join(skillDir, "SKILL.md");
   try {
-    await fs23.ensureDir(skillDir);
+    await fs21.ensureDir(skillDir);
     let frontmatter = `---
 name: ${skill.name}
 description: ${skill.description}`;
@@ -17869,7 +17980,7 @@ allowed-tools: ${skill.allowedTools.join(" ")}`;
 
 `;
     const content = frontmatter + skill.body + "\n";
-    await fs23.writeFile(skillPath, content, "utf-8");
+    await fs21.writeFile(skillPath, content, "utf-8");
     return true;
   } catch {
     return false;
@@ -17905,7 +18016,7 @@ async function runAutoSkillGeneration(workspaceRoot, llm) {
     result.error = "No skills generated";
     return result;
   }
-  const skillsDir = path21.join(workspaceRoot, PROJECT_DIR_NAME, "skills");
+  const skillsDir = path20.join(workspaceRoot, PROJECT_DIR_NAME, "skills");
   for (const skill of skills) {
     const saved = await saveSkill(skill, skillsDir);
     if (saved) {
@@ -17948,7 +18059,8 @@ var RPC_METHODS = {
   RESET: "autohand.reset",
   GET_STATE: "autohand.getState",
   GET_MESSAGES: "autohand.getMessages",
-  PERMISSION_RESPONSE: "autohand.permissionResponse"
+  PERMISSION_RESPONSE: "autohand.permissionResponse",
+  PERMISSION_ACKNOWLEDGED: "autohand.permissionAcknowledged"
 };
 var RPC_NOTIFICATIONS = {
   AGENT_START: "autohand.agentStart",
@@ -18212,6 +18324,7 @@ var RPCAdapter = class {
     this.imageManager = null;
     this.sessionId = null;
     this.currentTurnId = null;
+    this.turnStartTime = null;
     this.currentMessageId = null;
     this.currentMessageContent = "";
     this.pendingPermissions = /* @__PURE__ */ new Map();
@@ -18286,16 +18399,37 @@ var RPCAdapter = class {
     this.status = "processing";
     this.abortController = new AbortController();
     this.currentTurnId = generateId("turn");
+    this.turnStartTime = Date.now();
     writeNotification(RPC_NOTIFICATIONS.TURN_START, {
       turnId: this.currentTurnId,
       timestamp: createTimestamp()
     });
     try {
       const imagePlaceholders = [];
-      if (params.images && params.images.length > 0 && this.imageManager) {
+      process.stderr.write(`[RPC] handlePrompt: images=${params.images?.length || 0}, hasImageManager=${!!this.imageManager}, model=${this.model}
+`);
+      if (params.images && params.images.length > 0) {
+        if (!supportsVision(this.model)) {
+          process.stderr.write(`[RPC] WARNING: Model '${this.model}' does not support vision. Images will not be processed.
+`);
+          writeNotification(RPC_NOTIFICATIONS.ERROR, {
+            code: -32e3,
+            message: `Model '${this.model}' does not support image inputs. Please use a vision-capable model like claude-3.5-sonnet, gpt-4o, or gemini-1.5-pro.`,
+            recoverable: true,
+            timestamp: createTimestamp()
+          });
+        }
+      }
+      if (params.images && params.images.length > 0 && this.imageManager && supportsVision(this.model)) {
+        process.stderr.write(`[RPC] Processing ${params.images.length} images
+`);
         for (const img of params.images) {
           try {
+            process.stderr.write(`[RPC] Image: mimeType=${img.mimeType}, dataLength=${img.data?.length || 0}
+`);
             if (!isValidImageMimeType(img.mimeType)) {
+              process.stderr.write(`[RPC] Invalid MIME type: ${img.mimeType}
+`);
               writeNotification(RPC_NOTIFICATIONS.ERROR, {
                 code: -32602,
                 // Invalid params
@@ -18306,6 +18440,8 @@ var RPCAdapter = class {
               continue;
             }
             const data = Buffer.from(img.data, "base64");
+            process.stderr.write(`[RPC] Image decoded: ${data.length} bytes
+`);
             if (data.length > MAX_IMAGE_SIZE) {
               writeNotification(RPC_NOTIFICATIONS.ERROR, {
                 code: -32602,
@@ -18331,9 +18467,14 @@ var RPCAdapter = class {
       }
       let instruction = params.message;
       if (imagePlaceholders.length > 0) {
+        process.stderr.write(`[RPC] Image placeholders: ${imagePlaceholders.join(", ")}
+`);
         instruction = `${imagePlaceholders.join(" ")}
 
 ${instruction}`;
+      } else if (params.images && params.images.length > 0) {
+        process.stderr.write(`[RPC] WARNING: Images provided but no placeholders generated!
+`);
       }
       if (params.context?.selection) {
         const sel = params.context.selection;
@@ -18355,7 +18496,40 @@ ${sel.text}
       try {
         process.stderr.write(`[RPC DEBUG] Executing instruction: ${instruction.substring(0, 100)}
 `);
-        success = await this.agent.runInstruction(instruction);
+        if (this.agent.isSlashCommand(instruction)) {
+          const { command, args } = this.agent.parseSlashCommand(instruction);
+          process.stderr.write(`[RPC DEBUG] Handling slash command: ${command}, args: ${JSON.stringify(args)}
+`);
+          if (this.agent.isSlashCommandSupported(command)) {
+            const result = await this.agent.handleSlashCommand(command, args);
+            if (result !== null) {
+              this.currentMessageContent = result;
+              writeNotification(RPC_NOTIFICATIONS.MESSAGE_UPDATE, {
+                messageId: this.currentMessageId,
+                delta: result,
+                timestamp: createTimestamp()
+              });
+            } else {
+              this.currentMessageContent = `Command ${command} executed.`;
+              writeNotification(RPC_NOTIFICATIONS.MESSAGE_UPDATE, {
+                messageId: this.currentMessageId,
+                delta: this.currentMessageContent,
+                timestamp: createTimestamp()
+              });
+            }
+            success = true;
+          } else {
+            this.currentMessageContent = `Unknown command: ${command}. Type /help for available commands.`;
+            writeNotification(RPC_NOTIFICATIONS.MESSAGE_UPDATE, {
+              messageId: this.currentMessageId,
+              delta: this.currentMessageContent,
+              timestamp: createTimestamp()
+            });
+            success = false;
+          }
+        } else {
+          success = await this.agent.runInstruction(instruction);
+        }
         process.stderr.write(`[RPC DEBUG] Instruction completed, success=${success}, content length=${this.currentMessageContent.length}
 `);
       } catch (err) {
@@ -18378,24 +18552,34 @@ ${sel.text}
         content: this.currentMessageContent,
         timestamp: createTimestamp()
       });
+      const durationMs = this.turnStartTime ? Date.now() - this.turnStartTime : void 0;
+      const snapshot = this.agent?.getStatusSnapshot();
       writeNotification(RPC_NOTIFICATIONS.TURN_END, {
         turnId: this.currentTurnId,
         timestamp: createTimestamp(),
-        contextPercent: this.contextPercent
+        contextPercent: this.contextPercent,
+        tokensUsed: snapshot?.tokensUsed,
+        durationMs
       });
       this.status = "idle";
       this.currentTurnId = null;
+      this.turnStartTime = null;
       this.currentMessageId = null;
       this.abortController = null;
       return { success };
     } catch (error) {
+      const durationMs = this.turnStartTime ? Date.now() - this.turnStartTime : void 0;
+      const snapshot = this.agent?.getStatusSnapshot();
       writeNotification(RPC_NOTIFICATIONS.TURN_END, {
         turnId: this.currentTurnId,
         timestamp: createTimestamp(),
-        contextPercent: this.contextPercent
+        contextPercent: this.contextPercent,
+        tokensUsed: snapshot?.tokensUsed,
+        durationMs
       });
       this.status = "idle";
       this.currentTurnId = null;
+      this.turnStartTime = null;
       this.currentMessageId = null;
       this.abortController = null;
       throw error;
@@ -18405,24 +18589,41 @@ ${sel.text}
    * Handle abort request
    */
   handleAbort(requestId) {
+    process.stderr.write(`[RPC] handleAbort called, abortController=${!!this.abortController}
+`);
+    for (const [permId, pending] of this.pendingPermissions) {
+      process.stderr.write(`[RPC] Clearing pending permission ${permId} due to abort
+`);
+      if (pending.ackTimeout) clearTimeout(pending.ackTimeout);
+      if (pending.responseTimeout) clearTimeout(pending.responseTimeout);
+      pending.resolve(false);
+    }
+    this.pendingPermissions.clear();
     if (this.abortController) {
       this.abortController.abort();
       this.status = "idle";
       if (this.currentMessageId) {
         writeNotification(RPC_NOTIFICATIONS.MESSAGE_END, {
           messageId: this.currentMessageId,
-          content: this.currentMessageContent + "\n\n*[Aborted by user]*",
+          content: this.currentMessageContent,
+          // No marker - UI handles display
+          aborted: true,
           timestamp: createTimestamp()
         });
       }
       if (this.currentTurnId) {
+        const durationMs = this.turnStartTime ? Date.now() - this.turnStartTime : void 0;
+        const snapshot = this.agent?.getStatusSnapshot();
         writeNotification(RPC_NOTIFICATIONS.TURN_END, {
           turnId: this.currentTurnId,
           timestamp: createTimestamp(),
-          contextPercent: this.contextPercent
+          contextPercent: this.contextPercent,
+          tokensUsed: snapshot?.tokensUsed,
+          durationMs
         });
       }
       this.currentTurnId = null;
+      this.turnStartTime = null;
       this.currentMessageId = null;
       this.currentMessageContent = "";
       this.abortController = null;
@@ -18470,22 +18671,40 @@ ${sel.text}
    * Handle permission response from client
    */
   handlePermissionResponse(requestId, permRequestId, allowed) {
+    process.stderr.write(`[RPC] handlePermissionResponse called: permRequestId=${permRequestId}, allowed=${allowed}, pending keys=${Array.from(this.pendingPermissions.keys()).join(",")}
+`);
     const pending = this.pendingPermissions.get(permRequestId);
     if (pending) {
-      clearTimeout(pending.timeout);
+      process.stderr.write(`[RPC] Found pending permission, resolving with allowed=${allowed}
+`);
+      if (pending.ackTimeout) {
+        clearTimeout(pending.ackTimeout);
+      }
+      if (pending.responseTimeout) {
+        clearTimeout(pending.responseTimeout);
+      }
       this.pendingPermissions.delete(permRequestId);
       pending.resolve(allowed);
       this.status = "processing";
+      process.stderr.write(`[RPC] Permission resolved, status set to processing
+`);
       return { success: true };
     }
+    process.stderr.write(`[RPC] Permission response for unknown request ${permRequestId}
+`);
     return { success: false };
   }
   /**
    * Request permission from client (called from agent's confirmDangerousAction)
+   * Uses two-phase timeout:
+   * - Phase 1: 30s to receive acknowledgment from extension
+   * - Phase 2: 1 hour for user to respond after ack received
    */
   async requestPermission(tool, description, context) {
     const permRequestId = generateId("perm");
     this.status = "waiting_permission";
+    process.stderr.write(`[RPC] requestPermission: tool=${tool}, permRequestId=${permRequestId}
+`);
     writeNotification(RPC_NOTIFICATIONS.PERMISSION_REQUEST, {
       requestId: permRequestId,
       tool,
@@ -18494,19 +18713,53 @@ ${sel.text}
       timestamp: createTimestamp()
     });
     return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
+      const ackTimeout = setTimeout(() => {
         this.pendingPermissions.delete(permRequestId);
         this.status = "processing";
+        process.stderr.write(`[RPC] Permission ack timeout for ${permRequestId}
+`);
         resolve(false);
-      }, 6e4);
+      }, 3e4);
       this.pendingPermissions.set(permRequestId, {
         requestId: permRequestId,
         resolve,
         reject,
-        timeout
+        ackTimeout,
+        responseTimeout: null,
+        acknowledged: false
       });
     });
   }
+  /**
+   * Handle acknowledgment from client that permission UI is shown
+   * Extends timeout since we know extension is alive and user is deciding
+   */
+  handlePermissionAcknowledged(permRequestId) {
+    const pending = this.pendingPermissions.get(permRequestId);
+    if (!pending) {
+      process.stderr.write(`[RPC] Permission ack for unknown request ${permRequestId}
+`);
+      return { success: false };
+    }
+    if (pending.acknowledged) {
+      return { success: true };
+    }
+    if (pending.ackTimeout) {
+      clearTimeout(pending.ackTimeout);
+      pending.ackTimeout = null;
+    }
+    pending.acknowledged = true;
+    pending.responseTimeout = setTimeout(() => {
+      this.pendingPermissions.delete(permRequestId);
+      this.status = "processing";
+      process.stderr.write(`[RPC] Permission response timeout for ${permRequestId} (1 hour)
+`);
+      pending.resolve(false);
+    }, 36e5);
+    process.stderr.write(`[RPC] Permission acknowledged for ${permRequestId}
+`);
+    return { success: true };
+  }
   /**
    * Emit tool execution start notification
    */
@@ -18561,7 +18814,12 @@ ${sel.text}
    */
   shutdown(reason = "completed") {
     for (const [, pending] of this.pendingPermissions) {
-      clearTimeout(pending.timeout);
+      if (pending.ackTimeout) {
+        clearTimeout(pending.ackTimeout);
+      }
+      if (pending.responseTimeout) {
+        clearTimeout(pending.responseTimeout);
+      }
       pending.reject(new Error("Adapter shutdown"));
     }
     this.pendingPermissions.clear();
@@ -18736,9 +18994,8 @@ async function runRpcMode(options) {
       config,
       workspaceRoot,
       options: {
-        ...options,
-        // Auto-approve for MVP - proper permission handling via RPC coming later
-        yes: true
+        ...options
+        // Do NOT set yes: true - permissions are handled via RPC
       }
     };
     const provider = ProviderFactory.create(config);
@@ -18756,6 +19013,17 @@ async function runRpcMode(options) {
       options.model ?? config.openrouter?.model ?? "unknown",
       workspaceRoot
     );
+    agent.setConfirmationCallback(async (message, context) => {
+      if (!adapter) {
+        throw new Error("RPC adapter not initialized");
+      }
+      const tool = context?.tool ?? "action";
+      const description = message;
+      const permContext = {};
+      if (context?.command) permContext.command = context.command;
+      if (context?.path) permContext.path = context.path;
+      return adapter.requestPermission(tool, description, permContext);
+    });
     const reader = new LineReader(process.stdin);
     while (true) {
       try {
@@ -18813,8 +19081,21 @@ async function handleSingleRequest(request, adapter) {
           }
           return null;
         }
-        result = await adapter.handlePrompt(id, promptParams);
-        break;
+        adapter.handlePrompt(id, promptParams).then((promptResult) => {
+          if (shouldRespond) {
+            process.stdout.write(JSON.stringify(createResponse(id, promptResult)) + "\n");
+          }
+        }).catch((error) => {
+          const message = error instanceof Error ? error.message : String(error);
+          if (shouldRespond) {
+            process.stdout.write(JSON.stringify(createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+              message
+            )) + "\n");
+          }
+        });
+        return null;
       }
       case RPC_METHODS.ABORT: {
         result = adapter.handleAbort(id);
@@ -18848,6 +19129,21 @@ async function handleSingleRequest(request, adapter) {
         result = adapter.handlePermissionResponse(id, permParams.requestId, permParams.allowed);
         break;
       }
+      case RPC_METHODS.PERMISSION_ACKNOWLEDGED: {
+        const ackParams = params;
+        if (!ackParams?.requestId) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameter: requestId"
+            );
+          }
+          return null;
+        }
+        result = adapter.handlePermissionAcknowledged(ackParams.requestId);
+        break;
+      }
       default: {
         if (shouldRespond) {
           return createErrorResponse(
@@ -18879,6 +19175,9 @@ async function handleSingleRequest(request, adapter) {
 // src/index.ts
 process.title = "autohand";
 function getGitCommit() {
+  if (true) {
+    return "056d8fb";
+  }
   try {
     return execSync3("git rev-parse --short HEAD", { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }).trim();
   } catch {
@@ -18929,6 +19228,9 @@ process.on("uncaughtException", (err) => {
   process.exit(1);
 });
 process.on("unhandledRejection", (reason, promise) => {
+  if (reason && typeof reason === "object" && reason.code === "ERR_USE_AFTER_CLOSE") {
+    return;
+  }
   globalThis.__autohandLastError = reason;
   console.error("[DEBUG] Unhandled Rejection at:", promise, "reason:", reason);
 });
@@ -18943,7 +19245,11 @@ 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 changes after completing tasks", 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("--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("--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 changes after completing tasks", 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("--mode <mode>", "Run mode: interactive (default) or rpc", "interactive").action(async (opts) => {
+  if (opts.skillInstall !== void 0) {
+    await runSkillInstall(opts);
+    return;
+  }
   if (opts.mode === "rpc") {
     await runRpcMode(opts);
   } else {
@@ -18967,17 +19273,27 @@ async function runCLI(options) {
       }
       console.log(chalk15.yellow(`No ${providerName} API key configured.
 `));
-      const { apiKey } = await enquirer4.prompt({
-        type: "password",
-        name: "apiKey",
-        message: `Enter your ${providerName === "openrouter" ? "OpenRouter" : providerName} API key`,
-        validate: (val) => {
-          if (typeof val !== "string" || !val.trim()) {
-            return "API key is required";
+      let apiKey;
+      try {
+        const result = await enquirer4.prompt({
+          type: "password",
+          name: "apiKey",
+          message: `Enter your ${providerName === "openrouter" ? "OpenRouter" : providerName} API key`,
+          validate: (val) => {
+            if (typeof val !== "string" || !val.trim()) {
+              return "API key is required";
+            }
+            return true;
           }
-          return true;
+        });
+        apiKey = result.apiKey;
+      } catch (error) {
+        if (error?.code === "ERR_USE_AFTER_CLOSE" || error?.message?.includes("cancelled")) {
+          console.log(chalk15.gray("\nSetup cancelled."));
+          process.exit(0);
         }
-      });
+        throw error;
+      }
       if (providerName === "openrouter") {
         config.openrouter = {
           ...config.openrouter,
@@ -19079,6 +19395,21 @@ function printWelcome(runtime, authUser) {
   }
   console.log();
 }
+async function runSkillInstall(opts) {
+  const config = await loadConfig(opts.config);
+  const workspaceRoot = resolveWorkspaceRoot(config, opts.path);
+  const { SkillsRegistry: SkillsRegistry2 } = await import("./SkillsRegistry-SP5MX7OA.js");
+  const { AUTOHAND_PATHS: AUTOHAND_PATHS2 } = await import("./constants-N3I2FHCM.js");
+  const { skillsInstall } = await import("./skills-install-WJ2LDRQG.js");
+  const skillsRegistry = new SkillsRegistry2(AUTOHAND_PATHS2.skills);
+  await skillsRegistry.initialize();
+  await skillsRegistry.setWorkspace(workspaceRoot);
+  const skillName = typeof opts.skillInstall === "string" ? opts.skillInstall : void 0;
+  await skillsInstall({
+    skillsRegistry,
+    workspaceRoot
+  }, skillName);
+}
 program.parseAsync();
 /**
  * @license
@@ -19157,20 +19488,6 @@ program.parseAsync();
  * TelemetryManager - High-level telemetry tracking
  * @license Apache-2.0
  */
-/**
- * @license
- * Copyright 2025 Autohand AI LLC
- * SPDX-License-Identifier: Apache-2.0
- *
- * SkillParser - Parses SKILL.md files with YAML frontmatter
- */
-/**
- * @license
- * Copyright 2025 Autohand AI LLC
- * SPDX-License-Identifier: Apache-2.0
- *
- * SkillsRegistry - Manages skill discovery, loading, and activation
- */
 /**
  * @license
  * Copyright 2025 Autohand AI LLC