@adhdev/daemon-core 0.5.3 → 0.5.6

package/dist/index.js

@@ -30,6 +30,188 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/config/workspaces.ts
+function expandPath(p) {
+  const t = (p || "").trim();
+  if (!t) return "";
+  if (t.startsWith("~")) return path.join(os.homedir(), t.slice(1).replace(/^\//, ""));
+  return path.resolve(t);
+}
+function validateWorkspacePath(absPath) {
+  try {
+    if (!absPath) return { ok: false, error: "Path required" };
+    if (!fs.existsSync(absPath)) return { ok: false, error: "Path does not exist" };
+    const st = fs.statSync(absPath);
+    if (!st.isDirectory()) return { ok: false, error: "Not a directory" };
+    return { ok: true };
+  } catch (e) {
+    return { ok: false, error: e?.message || "Invalid path" };
+  }
+}
+function defaultWorkspaceLabel(absPath) {
+  const base = path.basename(absPath) || absPath;
+  return base;
+}
+function migrateWorkspacesFromRecent(config) {
+  if (!config.workspaces) config.workspaces = [];
+  if (config.workspaces.length > 0) return config;
+  const recent = config.recentCliWorkspaces || [];
+  const now = Date.now();
+  for (const raw of recent) {
+    const abs = expandPath(raw);
+    if (!abs || validateWorkspacePath(abs).ok !== true) continue;
+    if (config.workspaces.some((w) => path.resolve(w.path) === abs)) continue;
+    config.workspaces.push({
+      id: (0, import_crypto.randomUUID)(),
+      path: abs,
+      label: defaultWorkspaceLabel(abs),
+      addedAt: now
+    });
+    if (config.workspaces.length >= MAX_WORKSPACES) break;
+  }
+  return config;
+}
+function getDefaultWorkspacePath(config) {
+  const id = config.defaultWorkspaceId;
+  if (!id) return null;
+  const w = (config.workspaces || []).find((x) => x.id === id);
+  if (!w) return null;
+  const abs = expandPath(w.path);
+  if (validateWorkspacePath(abs).ok !== true) return null;
+  return abs;
+}
+function getWorkspaceState(config) {
+  const workspaces = [...config.workspaces || []].sort((a, b) => b.addedAt - a.addedAt);
+  const defaultWorkspacePath = getDefaultWorkspacePath(config);
+  return {
+    workspaces,
+    defaultWorkspaceId: config.defaultWorkspaceId ?? null,
+    defaultWorkspacePath
+  };
+}
+function resolveLaunchDirectory(args, config) {
+  const a = args || {};
+  if (a.dir != null && String(a.dir).trim()) {
+    const abs = expandPath(String(a.dir).trim());
+    if (abs && validateWorkspacePath(abs).ok === true) {
+      return { ok: true, path: abs, source: "dir" };
+    }
+    return {
+      ok: false,
+      code: "WORKSPACE_LAUNCH_CONTEXT_REQUIRED",
+      message: abs ? "Directory path is not valid or does not exist" : "Invalid directory path"
+    };
+  }
+  if (a.workspaceId) {
+    const w = (config.workspaces || []).find((x) => x.id === a.workspaceId);
+    if (w) {
+      const abs = expandPath(w.path);
+      if (validateWorkspacePath(abs).ok === true) {
+        return { ok: true, path: abs, source: "workspaceId" };
+      }
+    }
+    return {
+      ok: false,
+      code: "WORKSPACE_LAUNCH_CONTEXT_REQUIRED",
+      message: "Saved workspace not found or path is no longer valid"
+    };
+  }
+  if (a.useDefaultWorkspace === true) {
+    const d = getDefaultWorkspacePath(config);
+    if (d) return { ok: true, path: d, source: "defaultWorkspace" };
+    return {
+      ok: false,
+      code: "WORKSPACE_LAUNCH_CONTEXT_REQUIRED",
+      message: "No default workspace is set"
+    };
+  }
+  if (a.useHome === true) {
+    return { ok: true, path: os.homedir(), source: "home" };
+  }
+  return {
+    ok: false,
+    code: "WORKSPACE_LAUNCH_CONTEXT_REQUIRED",
+    message: "Choose a directory, saved workspace, default workspace, or home before launching."
+  };
+}
+function resolveIdeWorkspaceFromArgs(args, config) {
+  const ar = args || {};
+  if (ar.workspace) {
+    const abs = expandPath(ar.workspace);
+    if (abs && validateWorkspacePath(abs).ok === true) return abs;
+  }
+  if (ar.workspaceId) {
+    const w = (config.workspaces || []).find((x) => x.id === ar.workspaceId);
+    if (w) {
+      const abs = expandPath(w.path);
+      if (validateWorkspacePath(abs).ok === true) return abs;
+    }
+  }
+  if (ar.useDefaultWorkspace === true) {
+    return getDefaultWorkspacePath(config) || void 0;
+  }
+  return void 0;
+}
+function resolveIdeLaunchWorkspace(args, config) {
+  const direct = resolveIdeWorkspaceFromArgs(args, config);
+  if (direct) return direct;
+  if (args?.useDefaultWorkspace === false) return void 0;
+  return getDefaultWorkspacePath(config) || void 0;
+}
+function findWorkspaceByPath(config, rawPath) {
+  const abs = path.resolve(expandPath(rawPath));
+  if (!abs) return void 0;
+  return (config.workspaces || []).find((w) => path.resolve(expandPath(w.path)) === abs);
+}
+function addWorkspaceEntry(config, rawPath, label) {
+  const abs = expandPath(rawPath);
+  const v = validateWorkspacePath(abs);
+  if (!v.ok) return { error: v.error };
+  const list = [...config.workspaces || []];
+  if (list.some((w) => path.resolve(w.path) === abs)) {
+    return { error: "Workspace already in list" };
+  }
+  if (list.length >= MAX_WORKSPACES) {
+    return { error: `Maximum ${MAX_WORKSPACES} workspaces` };
+  }
+  const entry = {
+    id: (0, import_crypto.randomUUID)(),
+    path: abs,
+    label: (label || "").trim() || defaultWorkspaceLabel(abs),
+    addedAt: Date.now()
+  };
+  list.push(entry);
+  return { config: { ...config, workspaces: list }, entry };
+}
+function removeWorkspaceEntry(config, id) {
+  const list = (config.workspaces || []).filter((w) => w.id !== id);
+  if (list.length === (config.workspaces || []).length) return { error: "Workspace not found" };
+  let defaultWorkspaceId = config.defaultWorkspaceId;
+  if (defaultWorkspaceId === id) defaultWorkspaceId = null;
+  return { config: { ...config, workspaces: list, defaultWorkspaceId } };
+}
+function setDefaultWorkspaceId(config, id) {
+  if (id === null) {
+    return { config: { ...config, defaultWorkspaceId: null } };
+  }
+  const w = (config.workspaces || []).find((x) => x.id === id);
+  if (!w) return { error: "Workspace not found" };
+  const abs = expandPath(w.path);
+  if (validateWorkspacePath(abs).ok !== true) return { error: "Workspace path is no longer valid" };
+  return { config: { ...config, defaultWorkspaceId: id } };
+}
+var fs, os, path, import_crypto, MAX_WORKSPACES;
+var init_workspaces = __esm({
+  "src/config/workspaces.ts"() {
+    "use strict";
+    fs = __toESM(require("fs"));
+    os = __toESM(require("os"));
+    path = __toESM(require("path"));
+    import_crypto = require("crypto");
+    MAX_WORKSPACES = 50;
+  }
+});
+
 // src/config/config.ts
 var config_exports = {};
 __export(config_exports, {
@@ -61,7 +243,20 @@ function loadConfig() {
   try {
     const raw = (0, import_fs.readFileSync)(configPath, "utf-8");
     const parsed = JSON.parse(raw);
-    return { ...DEFAULT_CONFIG, ...parsed };
+    const merged = { ...DEFAULT_CONFIG, ...parsed };
+    if (merged.defaultWorkspaceId == null && merged.activeWorkspaceId != null) {
+      merged.defaultWorkspaceId = merged.activeWorkspaceId;
+    }
+    delete merged.activeWorkspaceId;
+    const hadStoredWorkspaces = Array.isArray(parsed.workspaces) && parsed.workspaces.length > 0;
+    migrateWorkspacesFromRecent(merged);
+    if (!hadStoredWorkspaces && (merged.workspaces?.length || 0) > 0) {
+      try {
+        saveConfig(merged);
+      } catch {
+      }
+    }
+    return merged;
   } catch {
     return { ...DEFAULT_CONFIG };
   }
@@ -132,6 +327,7 @@ var init_config = __esm({
     import_os = require("os");
     import_path = require("path");
     import_fs = require("fs");
+    init_workspaces();
     DEFAULT_CONFIG = {
       serverUrl: "https://api.adhf.dev",
       apiToken: null,
@@ -148,6 +344,9 @@ var init_config = __esm({
       configuredCLIs: [],
       enabledIdes: [],
       recentCliWorkspaces: [],
+      workspaces: [],
+      defaultWorkspaceId: null,
+      recentWorkspaceActivity: [],
       machineNickname: null,
       cliHistory: [],
       providerSettings: {},
@@ -187,9 +386,12 @@ __export(index_exports, {
   detectIDEs: () => detectIDEs,
   getAIExtensions: () => getAIExtensions,
   getAvailableIdeIds: () => getAvailableIdeIds,
+  getHostMemorySnapshot: () => getHostMemorySnapshot,
   getLogLevel: () => getLogLevel,
   getRecentCommands: () => getRecentCommands,
   getRecentLogs: () => getRecentLogs,
+  getWorkspaceActivity: () => getWorkspaceActivity,
+  getWorkspaceState: () => getWorkspaceState,
   initDaemonComponents: () => initDaemonComponents,
   installExtensions: () => installExtensions,
   installGlobalInterceptor: () => installGlobalInterceptor,
@@ -212,6 +414,47 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 init_config();
+init_workspaces();
+
+// src/config/workspace-activity.ts
+var path2 = __toESM(require("path"));
+init_workspaces();
+var MAX_ACTIVITY = 30;
+function normWorkspacePath(p) {
+  try {
+    return path2.resolve(expandPath(p));
+  } catch {
+    return path2.resolve(p);
+  }
+}
+function appendWorkspaceActivity(config, rawPath, meta) {
+  const abs = normWorkspacePath(rawPath);
+  if (!abs) return config;
+  const prev = config.recentWorkspaceActivity || [];
+  const filtered = prev.filter((e) => normWorkspacePath(e.path) !== abs);
+  const entry = {
+    path: abs,
+    lastUsedAt: Date.now(),
+    kind: meta?.kind,
+    agentType: meta?.agentType
+  };
+  const recentWorkspaceActivity = [entry, ...filtered].slice(0, MAX_ACTIVITY);
+  return { ...config, recentWorkspaceActivity };
+}
+function getWorkspaceActivity(config, limit = 20) {
+  const list = [...config.recentWorkspaceActivity || []];
+  list.sort((a, b) => b.lastUsedAt - a.lastUsedAt);
+  return list.slice(0, limit);
+}
+function removeActivityForPath(config, rawPath) {
+  const n = normWorkspacePath(rawPath);
+  return {
+    ...config,
+    recentWorkspaceActivity: (config.recentWorkspaceActivity || []).filter(
+      (e) => normWorkspacePath(e.path) !== n
+    )
+  };
+}
 
 // src/detection/ide-detector.ts
 var import_child_process = require("child_process");
@@ -271,20 +514,20 @@ function checkPathExists(paths) {
   return null;
 }
 async function detectIDEs() {
-  const os13 = (0, import_os2.platform)();
+  const os15 = (0, import_os2.platform)();
   const results = [];
   for (const def of getMergedDefinitions()) {
     const cliPath = findCliCommand(def.cli);
-    const appPath = checkPathExists(def.paths[os13] || []);
+    const appPath = checkPathExists(def.paths[os15] || []);
     const installed = !!(cliPath || appPath);
     let resolvedCli = cliPath;
-    if (!resolvedCli && appPath && os13 === "darwin") {
+    if (!resolvedCli && appPath && os15 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
       if ((0, import_fs2.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
-    if (!resolvedCli && appPath && os13 === "win32") {
-      const { dirname: dirname5 } = await import("path");
-      const appDir = dirname5(appPath);
+    if (!resolvedCli && appPath && os15 === "win32") {
+      const { dirname: dirname6 } = await import("path");
+      const appDir = dirname6(appPath);
       const candidates = [
         `${appDir}\\\\bin\\\\${def.cli}.cmd`,
         `${appDir}\\\\bin\\\\${def.cli}`,
@@ -317,22 +560,22 @@ async function detectIDEs() {
 
 // src/detection/cli-detector.ts
 var import_child_process2 = require("child_process");
-var os = __toESM(require("os"));
+var os2 = __toESM(require("os"));
 function execAsync(cmd, timeoutMs = 5e3) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve7) => {
     const child = (0, import_child_process2.exec)(cmd, { encoding: "utf-8", timeout: timeoutMs }, (err, stdout) => {
       if (err || !stdout?.trim()) {
-        resolve5(null);
+        resolve7(null);
       } else {
-        resolve5(stdout.trim());
+        resolve7(stdout.trim());
       }
     });
-    child.on("error", () => resolve5(null));
+    child.on("error", () => resolve7(null));
   });
 }
 async function detectCLIs(providerLoader) {
-  const platform7 = os.platform();
-  const whichCmd = platform7 === "win32" ? "where" : "which";
+  const platform8 = os2.platform();
+  const whichCmd = platform8 === "win32" ? "where" : "which";
   const cliList = providerLoader ? providerLoader.getCliDetectionList() : [];
   const results = await Promise.all(
     cliList.map(async (cli) => {
@@ -363,14 +606,56 @@ async function detectCLI(cliId, providerLoader) {
   return all.find((c) => c.id === resolvedId && c.installed) || null;
 }
 
+// src/system/host-memory.ts
+var os3 = __toESM(require("os"));
+var import_child_process3 = require("child_process");
+function parseDarwinAvailableBytes(totalMem) {
+  if (os3.platform() !== "darwin") return null;
+  try {
+    const out = (0, import_child_process3.execSync)("vm_stat", {
+      encoding: "utf-8",
+      timeout: 4e3,
+      maxBuffer: 256 * 1024
+    });
+    const pageSizeMatch = out.match(/page size of (\d+)\s*bytes/i);
+    const pageSize = pageSizeMatch ? parseInt(pageSizeMatch[1], 10) : 4096;
+    const counts = {};
+    for (const line of out.split("\n")) {
+      const m = line.match(/^\s*Pages\s+([^:]+):\s+([\d,]+)\s*\.?/);
+      if (!m) continue;
+      const key = m[1].trim().toLowerCase().replace(/\s+/g, "_");
+      const n = parseInt(m[2].replace(/,/g, ""), 10);
+      if (!Number.isNaN(n)) counts[key] = n;
+    }
+    const free = counts["free"] ?? 0;
+    const inactive = counts["inactive"] ?? 0;
+    const speculative = counts["speculative"] ?? 0;
+    const purgeable = counts["purgeable"] ?? 0;
+    const fileBacked = counts["file_backed"] ?? 0;
+    const availPages = free + inactive + speculative + purgeable + fileBacked;
+    const bytes = availPages * pageSize;
+    if (!Number.isFinite(bytes) || bytes < 0) return null;
+    return Math.min(bytes, totalMem);
+  } catch {
+    return null;
+  }
+}
+function getHostMemorySnapshot() {
+  const totalMem = os3.totalmem();
+  const freeMem = os3.freemem();
+  const darwinAvail = parseDarwinAvailableBytes(totalMem);
+  const availableMem = darwinAvail != null ? darwinAvail : freeMem;
+  return { totalMem, freeMem, availableMem };
+}
+
 // src/cdp/manager.ts
 var import_ws = __toESM(require("ws"));
 var http = __toESM(require("http"));
 
 // src/logging/logger.ts
-var fs = __toESM(require("fs"));
-var path = __toESM(require("path"));
-var os2 = __toESM(require("os"));
+var fs2 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var os4 = __toESM(require("os"));
 var LEVEL_NUM = { debug: 0, info: 1, warn: 2, error: 3 };
 var LEVEL_LABEL = { debug: "DBG", info: "INF", warn: "WRN", error: "ERR" };
 var currentLevel = "info";
@@ -381,29 +666,29 @@ function setLogLevel(level) {
 function getLogLevel() {
   return currentLevel;
 }
-var LOG_DIR = process.platform === "darwin" ? path.join(os2.homedir(), "Library", "Logs", "adhdev") : path.join(os2.homedir(), ".local", "share", "adhdev", "logs");
+var LOG_DIR = process.platform === "darwin" ? path3.join(os4.homedir(), "Library", "Logs", "adhdev") : path3.join(os4.homedir(), ".local", "share", "adhdev", "logs");
 var MAX_LOG_SIZE = 5 * 1024 * 1024;
 var MAX_LOG_DAYS = 7;
 try {
-  fs.mkdirSync(LOG_DIR, { recursive: true });
+  fs2.mkdirSync(LOG_DIR, { recursive: true });
 } catch {
 }
 function getDateStr() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
 var currentDate = getDateStr();
-var currentLogFile = path.join(LOG_DIR, `daemon-${currentDate}.log`);
+var currentLogFile = path3.join(LOG_DIR, `daemon-${currentDate}.log`);
 function checkDateRotation() {
   const today = getDateStr();
   if (today !== currentDate) {
     currentDate = today;
-    currentLogFile = path.join(LOG_DIR, `daemon-${currentDate}.log`);
+    currentLogFile = path3.join(LOG_DIR, `daemon-${currentDate}.log`);
     cleanOldLogs();
   }
 }
 function cleanOldLogs() {
   try {
-    const files = fs.readdirSync(LOG_DIR).filter((f) => f.startsWith("daemon-") && f.endsWith(".log"));
+    const files = fs2.readdirSync(LOG_DIR).filter((f) => f.startsWith("daemon-") && f.endsWith(".log"));
     const cutoff = /* @__PURE__ */ new Date();
     cutoff.setDate(cutoff.getDate() - MAX_LOG_DAYS);
     const cutoffStr = cutoff.toISOString().slice(0, 10);
@@ -411,7 +696,7 @@ function cleanOldLogs() {
       const dateMatch = file.match(/daemon-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs.unlinkSync(path.join(LOG_DIR, file));
+          fs2.unlinkSync(path3.join(LOG_DIR, file));
         } catch {
         }
       }
@@ -421,29 +706,29 @@ function cleanOldLogs() {
 }
 function rotateSizeIfNeeded() {
   try {
-    const stat = fs.statSync(currentLogFile);
+    const stat = fs2.statSync(currentLogFile);
     if (stat.size > MAX_LOG_SIZE) {
       const backup = currentLogFile.replace(".log", ".1.log");
       try {
-        fs.unlinkSync(backup);
+        fs2.unlinkSync(backup);
       } catch {
       }
-      fs.renameSync(currentLogFile, backup);
+      fs2.renameSync(currentLogFile, backup);
     }
   } catch {
   }
 }
 cleanOldLogs();
 try {
-  const oldLog = path.join(LOG_DIR, "daemon.log");
-  if (fs.existsSync(oldLog)) {
-    const stat = fs.statSync(oldLog);
+  const oldLog = path3.join(LOG_DIR, "daemon.log");
+  if (fs2.existsSync(oldLog)) {
+    const stat = fs2.statSync(oldLog);
     const oldDate = stat.mtime.toISOString().slice(0, 10);
-    fs.renameSync(oldLog, path.join(LOG_DIR, `daemon-${oldDate}.log`));
+    fs2.renameSync(oldLog, path3.join(LOG_DIR, `daemon-${oldDate}.log`));
   }
-  const oldLogBackup = path.join(LOG_DIR, "daemon.log.old");
-  if (fs.existsSync(oldLogBackup)) {
-    fs.unlinkSync(oldLogBackup);
+  const oldLogBackup = path3.join(LOG_DIR, "daemon.log.old");
+  if (fs2.existsSync(oldLogBackup)) {
+    fs2.unlinkSync(oldLogBackup);
   }
 } catch {
 }
@@ -454,7 +739,7 @@ function writeToFile(line) {
       checkDateRotation();
       rotateSizeIfNeeded();
     }
-    fs.appendFileSync(currentLogFile, line + "\n");
+    fs2.appendFileSync(currentLogFile, line + "\n");
   } catch {
   }
 }
@@ -568,7 +853,7 @@ function installGlobalInterceptor() {
   writeToFile(`Log file: ${currentLogFile}`);
   writeToFile(`Log level: ${currentLevel}`);
 }
-var LOG_PATH = path.join(LOG_DIR, `daemon-${getDateStr()}.log`);
+var LOG_PATH = path3.join(LOG_DIR, `daemon-${getDateStr()}.log`);
 
 // src/cdp/manager.ts
 var DaemonCdpManager = class {
@@ -643,7 +928,7 @@ var DaemonCdpManager = class {
   * Returns multiple entries if multiple IDE windows are open on same port
   */
   static listAllTargets(port) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve7) => {
       const req = http.get(`http://127.0.0.1:${port}/json`, (res) => {
         let data = "";
         res.on("data", (chunk) => data += chunk.toString());
@@ -659,16 +944,16 @@ var DaemonCdpManager = class {
               (t) => !isNonMain(t.title || "") && t.url?.includes("workbench.html") && !t.url?.includes("agent")
             );
             const fallbackPages = pages.filter((t) => !isNonMain(t.title || ""));
-            resolve5(mainPages.length > 0 ? mainPages : fallbackPages);
+            resolve7(mainPages.length > 0 ? mainPages : fallbackPages);
           } catch {
-            resolve5([]);
+            resolve7([]);
           }
         });
       });
-      req.on("error", () => resolve5([]));
+      req.on("error", () => resolve7([]));
       req.setTimeout(2e3, () => {
         req.destroy();
-        resolve5([]);
+        resolve7([]);
       });
     });
   }
@@ -708,7 +993,7 @@ var DaemonCdpManager = class {
     }
   }
   findTargetOnPort(port) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve7) => {
       const req = http.get(`http://127.0.0.1:${port}/json`, (res) => {
         let data = "";
         res.on("data", (chunk) => data += chunk.toString());
@@ -719,7 +1004,7 @@ var DaemonCdpManager = class {
               (t) => (t.type === "page" || t.type === "browser" || t.type === "Page") && t.webSocketDebuggerUrl
             );
             if (pages.length === 0) {
-              resolve5(targets.find((t) => t.webSocketDebuggerUrl) || null);
+              resolve7(targets.find((t) => t.webSocketDebuggerUrl) || null);
               return;
             }
             const mainPages = pages.filter((t) => !this.isNonMainTitle(t.title || ""));
@@ -729,24 +1014,24 @@ var DaemonCdpManager = class {
               const specific = list.find((t) => t.id === this._targetId);
               if (specific) {
                 this._pageTitle = specific.title || "";
-                resolve5(specific);
+                resolve7(specific);
               } else {
                 this.log(`[CDP] Target ${this._targetId} not found in page list`);
-                resolve5(null);
+                resolve7(null);
               }
               return;
             }
             this._pageTitle = list[0]?.title || "";
-            resolve5(list[0]);
+            resolve7(list[0]);
           } catch {
-            resolve5(null);
+            resolve7(null);
           }
         });
       });
-      req.on("error", () => resolve5(null));
+      req.on("error", () => resolve7(null));
       req.setTimeout(2e3, () => {
         req.destroy();
-        resolve5(null);
+        resolve7(null);
       });
     });
   }
@@ -757,7 +1042,7 @@ var DaemonCdpManager = class {
     this.extensionProviders = providers;
   }
   connectToTarget(wsUrl) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve7) => {
       this.ws = new import_ws.default(wsUrl);
       this.ws.on("open", async () => {
         this._connected = true;
@@ -767,17 +1052,17 @@ var DaemonCdpManager = class {
         }
         this.connectBrowserWs().catch(() => {
         });
-        resolve5(true);
+        resolve7(true);
       });
       this.ws.on("message", (data) => {
         try {
           const msg = JSON.parse(data.toString());
           if (msg.id && this.pending.has(msg.id)) {
-            const { resolve: resolve6, reject } = this.pending.get(msg.id);
+            const { resolve: resolve8, reject } = this.pending.get(msg.id);
             this.pending.delete(msg.id);
             this.failureCount = 0;
             if (msg.error) reject(new Error(msg.error.message));
-            else resolve6(msg.result);
+            else resolve8(msg.result);
           } else if (msg.method === "Runtime.executionContextCreated") {
             this.contexts.add(msg.params.context.id);
           } else if (msg.method === "Runtime.executionContextDestroyed") {
@@ -800,7 +1085,7 @@ var DaemonCdpManager = class {
       this.ws.on("error", (err) => {
         this.log(`[CDP] WebSocket error: ${err.message}`);
         this._connected = false;
-        resolve5(false);
+        resolve7(false);
       });
     });
   }
@@ -814,7 +1099,7 @@ var DaemonCdpManager = class {
         return;
       }
       this.log(`[CDP] Connecting browser WS for target discovery...`);
-      await new Promise((resolve5, reject) => {
+      await new Promise((resolve7, reject) => {
         this.browserWs = new import_ws.default(browserWsUrl);
         this.browserWs.on("open", async () => {
           this._browserConnected = true;
@@ -824,16 +1109,16 @@ var DaemonCdpManager = class {
           } catch (e) {
             this.log(`[CDP] setDiscoverTargets failed: ${e.message}`);
           }
-          resolve5();
+          resolve7();
         });
         this.browserWs.on("message", (data) => {
           try {
             const msg = JSON.parse(data.toString());
             if (msg.id && this.browserPending.has(msg.id)) {
-              const { resolve: resolve6, reject: reject2 } = this.browserPending.get(msg.id);
+              const { resolve: resolve8, reject: reject2 } = this.browserPending.get(msg.id);
               this.browserPending.delete(msg.id);
               if (msg.error) reject2(new Error(msg.error.message));
-              else resolve6(msg.result);
+              else resolve8(msg.result);
             }
           } catch {
           }
@@ -853,31 +1138,31 @@ var DaemonCdpManager = class {
     }
   }
   getBrowserWsUrl() {
-    return new Promise((resolve5) => {
+    return new Promise((resolve7) => {
       const req = http.get(`http://127.0.0.1:${this.port}/json/version`, (res) => {
         let data = "";
         res.on("data", (chunk) => data += chunk.toString());
         res.on("end", () => {
           try {
             const info = JSON.parse(data);
-            resolve5(info.webSocketDebuggerUrl || null);
+            resolve7(info.webSocketDebuggerUrl || null);
           } catch {
-            resolve5(null);
+            resolve7(null);
           }
         });
       });
-      req.on("error", () => resolve5(null));
+      req.on("error", () => resolve7(null));
       req.setTimeout(3e3, () => {
         req.destroy();
-        resolve5(null);
+        resolve7(null);
       });
     });
   }
   sendBrowser(method, params = {}, timeoutMs = 15e3) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve7, reject) => {
       if (!this.browserWs || !this._browserConnected) return reject(new Error("Browser WS not connected"));
       const id = this.browserMsgId++;
-      this.browserPending.set(id, { resolve: resolve5, reject });
+      this.browserPending.set(id, { resolve: resolve7, reject });
       this.browserWs.send(JSON.stringify({ id, method, params }));
       setTimeout(() => {
         if (this.browserPending.has(id)) {
@@ -917,11 +1202,11 @@ var DaemonCdpManager = class {
   }
   // ─── CDP Protocol ────────────────────────────────────────
   sendInternal(method, params = {}, timeoutMs = 15e3) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve7, reject) => {
       if (!this.ws || !this._connected) return reject(new Error("CDP not connected"));
       if (this.ws.readyState !== import_ws.default.OPEN) return reject(new Error("WebSocket not open"));
       const id = this.msgId++;
-      this.pending.set(id, { resolve: resolve5, reject });
+      this.pending.set(id, { resolve: resolve7, reject });
       this.ws.send(JSON.stringify({ id, method, params }));
       setTimeout(() => {
         if (this.pending.has(id)) {
@@ -1130,7 +1415,7 @@ var DaemonCdpManager = class {
     const browserWs = this.browserWs;
     let msgId = this.browserMsgId;
     const sendWs = (method, params = {}, sessionId) => {
-      return new Promise((resolve5, reject) => {
+      return new Promise((resolve7, reject) => {
         const mid = msgId++;
         this.browserMsgId = msgId;
         const handler = (raw) => {
@@ -1139,7 +1424,7 @@ var DaemonCdpManager = class {
             if (msg.id === mid) {
               browserWs.removeListener("message", handler);
               if (msg.error) reject(new Error(msg.error.message || JSON.stringify(msg.error)));
-              else resolve5(msg.result);
+              else resolve7(msg.result);
             }
           } catch {
           }
@@ -1313,14 +1598,14 @@ var DaemonCdpManager = class {
     if (!ws || ws.readyState !== import_ws.default.OPEN) {
       throw new Error("CDP not connected");
     }
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve7, reject) => {
       const id = getNextId();
       pendingMap.set(id, {
         resolve: (result) => {
           if (result?.result?.subtype === "error") {
             reject(new Error(result.result.description));
           } else {
-            resolve5(result?.result?.value);
+            resolve7(result?.result?.value);
           }
         },
         reject
@@ -1901,10 +2186,10 @@ var ExtensionProviderInstance = class {
 };
 
 // src/config/chat-history.ts
-var fs2 = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
-var os3 = __toESM(require("os"));
-var HISTORY_DIR = path2.join(os3.homedir(), ".adhdev", "history");
+var fs3 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var os5 = __toESM(require("os"));
+var HISTORY_DIR = path4.join(os5.homedir(), ".adhdev", "history");
 var RETAIN_DAYS = 30;
 var ChatHistoryWriter = class {
   /** Last seen message count per agent (deduplication) */
@@ -1945,13 +2230,13 @@ var ChatHistoryWriter = class {
         });
       }
       if (newMessages.length === 0) return;
-      const dir = path2.join(HISTORY_DIR, this.sanitize(agentType));
-      fs2.mkdirSync(dir, { recursive: true });
+      const dir = path4.join(HISTORY_DIR, this.sanitize(agentType));
+      fs3.mkdirSync(dir, { recursive: true });
       const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const filePrefix = instanceId ? `${this.sanitize(instanceId)}_` : "";
-      const filePath = path2.join(dir, `${filePrefix}${date}.jsonl`);
+      const filePath = path4.join(dir, `${filePrefix}${date}.jsonl`);
       const lines = newMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
-      fs2.appendFileSync(filePath, lines, "utf-8");
+      fs3.appendFileSync(filePath, lines, "utf-8");
       const prevCount = this.lastSeenCounts.get(dedupKey) || 0;
       if (messages.length < prevCount * 0.5 && prevCount > 3) {
         seenHashes.clear();
@@ -1976,17 +2261,17 @@ var ChatHistoryWriter = class {
   /** Delete history files older than 30 days */
   async rotateOldFiles() {
     try {
-      if (!fs2.existsSync(HISTORY_DIR)) return;
+      if (!fs3.existsSync(HISTORY_DIR)) return;
       const cutoff = Date.now() - RETAIN_DAYS * 24 * 60 * 60 * 1e3;
-      const agentDirs = fs2.readdirSync(HISTORY_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+      const agentDirs = fs3.readdirSync(HISTORY_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
       for (const dir of agentDirs) {
-        const dirPath = path2.join(HISTORY_DIR, dir.name);
-        const files = fs2.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl"));
+        const dirPath = path4.join(HISTORY_DIR, dir.name);
+        const files = fs3.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl"));
         for (const file of files) {
-          const filePath = path2.join(dirPath, file);
-          const stat = fs2.statSync(filePath);
+          const filePath = path4.join(dirPath, file);
+          const stat = fs3.statSync(filePath);
           if (stat.mtimeMs < cutoff) {
-            fs2.unlinkSync(filePath);
+            fs3.unlinkSync(filePath);
           }
         }
       }
@@ -2001,10 +2286,10 @@ var ChatHistoryWriter = class {
 function readChatHistory(agentType, offset = 0, limit = 30, instanceId) {
   try {
     const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, "_");
-    const dir = path2.join(HISTORY_DIR, sanitized);
-    if (!fs2.existsSync(dir)) return { messages: [], hasMore: false };
+    const dir = path4.join(HISTORY_DIR, sanitized);
+    if (!fs3.existsSync(dir)) return { messages: [], hasMore: false };
     const sanitizedInstance = instanceId?.replace(/[^a-zA-Z0-9_-]/g, "_");
-    const files = fs2.readdirSync(dir).filter((f) => {
+    const files = fs3.readdirSync(dir).filter((f) => {
       if (!f.endsWith(".jsonl")) return false;
       if (sanitizedInstance) {
         return f.startsWith(`${sanitizedInstance}_`);
@@ -2015,8 +2300,8 @@ function readChatHistory(agentType, offset = 0, limit = 30, instanceId) {
     const needed = offset + limit + 1;
     for (const file of files) {
       if (allMessages.length >= needed) break;
-      const filePath = path2.join(dir, file);
-      const content = fs2.readFileSync(filePath, "utf-8");
+      const filePath = path4.join(dir, file);
+      const content = fs3.readFileSync(filePath, "utf-8");
       const lines = content.trim().split("\n").filter(Boolean);
       for (let i = lines.length - 1; i >= 0; i--) {
         if (allMessages.length >= needed) break;
@@ -2256,6 +2541,15 @@ var IdeProviderInstance = class {
         const h = `${msg.role}:${(msg.content || "").slice(0, 100)}`;
         msg.receivedAt = prevByHash.get(h) || now;
       }
+      if (raw.messages?.length > 0) {
+        const hiddenKinds = /* @__PURE__ */ new Set();
+        if (this.settings.showThinking === false) hiddenKinds.add("thought");
+        if (this.settings.showToolCalls === false) hiddenKinds.add("tool");
+        if (this.settings.showTerminal === false) hiddenKinds.add("terminal");
+        if (hiddenKinds.size > 0) {
+          raw.messages = raw.messages.filter((m) => !hiddenKinds.has(m.kind));
+        }
+      }
       this.cachedChat = { ...raw, activeModal };
       this.detectAgentTransitions(raw, now);
       if (raw.messages?.length > 0) {
@@ -3274,6 +3568,39 @@ async function handleResolveAction(h, args) {
   const action = args?.action || "approve";
   const button = args?.button || args?.buttonText || (action === "approve" ? "Accept" : action === "reject" ? "Reject" : "Accept");
   LOG.info("Command", `[resolveAction] action=${action} button="${button}" provider=${provider?.type}`);
+  if (provider?.category === "cli") {
+    const adapter = h.getCliAdapter(provider.type);
+    if (!adapter) return { success: false, error: "CLI adapter not running" };
+    const status = adapter.getStatus?.();
+    if (status?.status !== "waiting_approval") {
+      return { success: false, error: "Not in approval state" };
+    }
+    const buttons = status.activeModal?.buttons || ["Allow once", "Always allow", "Deny"];
+    let buttonIndex = typeof args?.buttonIndex === "number" ? args.buttonIndex : -1;
+    if (buttonIndex < 0) {
+      const btnLower = button.toLowerCase();
+      buttonIndex = buttons.findIndex((b) => b.toLowerCase().includes(btnLower));
+    }
+    if (buttonIndex < 0) {
+      if (action === "reject" || action === "deny") {
+        buttonIndex = buttons.findIndex((b) => /deny|reject|no/i.test(b));
+        if (buttonIndex < 0) buttonIndex = buttons.length - 1;
+      } else if (action === "always" || /always/i.test(button)) {
+        buttonIndex = buttons.findIndex((b) => /always/i.test(b));
+        if (buttonIndex < 0) buttonIndex = 1;
+      } else {
+        buttonIndex = 0;
+      }
+    }
+    if (typeof adapter.resolveModal === "function") {
+      adapter.resolveModal(buttonIndex);
+    } else {
+      const keys = "\x1B[B".repeat(Math.max(0, buttonIndex)) + "\r";
+      adapter.writeRaw?.(keys);
+    }
+    LOG.info("Command", `[resolveAction] CLI PTY \u2192 buttonIndex=${buttonIndex} "${buttons[buttonIndex] ?? "?"}"`);
+    return { success: true, buttonIndex, button: buttons[buttonIndex] ?? button };
+  }
   if (provider?.category === "extension" && h.agentStream && h.getCdp()) {
     const ok = await h.agentStream.resolveAgentAction(
       h.getCdp(),
@@ -3360,9 +3687,9 @@ async function handleResolveAction(h, args) {
 }
 
 // src/commands/cdp-commands.ts
-var fs3 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
-var os4 = __toESM(require("os"));
+var fs4 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var os6 = __toESM(require("os"));
 async function handleCdpEval(h, args) {
   if (!h.getCdp()?.isConnected) return { success: false, error: "CDP not connected" };
   const expression = args?.expression || args?.script;
@@ -3514,21 +3841,21 @@ async function handleDiscoverAgents(h, args) {
   return { success: true, agents };
 }
 function resolveSafePath(requestedPath) {
-  const home = os4.homedir();
+  const home = os6.homedir();
   let resolved;
   if (requestedPath.startsWith("~")) {
-    resolved = path3.join(home, requestedPath.slice(1));
-  } else if (path3.isAbsolute(requestedPath)) {
+    resolved = path5.join(home, requestedPath.slice(1));
+  } else if (path5.isAbsolute(requestedPath)) {
     resolved = requestedPath;
   } else {
-    resolved = path3.resolve(requestedPath);
+    resolved = path5.resolve(requestedPath);
   }
   return resolved;
 }
 async function handleFileRead(h, args) {
   try {
     const filePath = resolveSafePath(args?.path);
-    const content = fs3.readFileSync(filePath, "utf-8");
+    const content = fs4.readFileSync(filePath, "utf-8");
     return { success: true, content, path: filePath };
   } catch (e) {
     return { success: false, error: e.message };
@@ -3537,8 +3864,8 @@ async function handleFileRead(h, args) {
 async function handleFileWrite(h, args) {
   try {
     const filePath = resolveSafePath(args?.path);
-    fs3.mkdirSync(path3.dirname(filePath), { recursive: true });
-    fs3.writeFileSync(filePath, args?.content || "", "utf-8");
+    fs4.mkdirSync(path5.dirname(filePath), { recursive: true });
+    fs4.writeFileSync(filePath, args?.content || "", "utf-8");
     return { success: true, path: filePath };
   } catch (e) {
     return { success: false, error: e.message };
@@ -3547,11 +3874,11 @@ async function handleFileWrite(h, args) {
 async function handleFileList(h, args) {
   try {
     const dirPath = resolveSafePath(args?.path || ".");
-    const entries = fs3.readdirSync(dirPath, { withFileTypes: true });
+    const entries = fs4.readdirSync(dirPath, { withFileTypes: true });
     const files = entries.map((e) => ({
       name: e.name,
       type: e.isDirectory() ? "directory" : "file",
-      size: e.isFile() ? fs3.statSync(path3.join(dirPath, e.name)).size : void 0
+      size: e.isFile() ? fs4.statSync(path5.join(dirPath, e.name)).size : void 0
     }));
     return { success: true, files, path: dirPath };
   } catch (e) {
@@ -3841,7 +4168,95 @@ function handleSetIdeExtension(h, args) {
   return { success: false, error: "Failed to save setting" };
 }
 
+// src/commands/workspace-commands.ts
+init_config();
+init_workspaces();
+function handleWorkspaceList() {
+  const config = loadConfig();
+  const state = getWorkspaceState(config);
+  return {
+    success: true,
+    workspaces: state.workspaces,
+    defaultWorkspaceId: state.defaultWorkspaceId,
+    defaultWorkspacePath: state.defaultWorkspacePath,
+    legacyRecentPaths: config.recentCliWorkspaces || [],
+    activity: getWorkspaceActivity(config, 25)
+  };
+}
+function handleWorkspaceAdd(args) {
+  const rawPath = (args?.path || args?.dir || "").trim();
+  const label = (args?.label || "").trim() || void 0;
+  if (!rawPath) return { success: false, error: "path required" };
+  const config = loadConfig();
+  const result = addWorkspaceEntry(config, rawPath, label);
+  if ("error" in result) return { success: false, error: result.error };
+  let cfg = appendWorkspaceActivity(result.config, result.entry.path, {});
+  saveConfig(cfg);
+  const state = getWorkspaceState(cfg);
+  return { success: true, entry: result.entry, ...state, activity: getWorkspaceActivity(cfg, 25) };
+}
+function handleWorkspaceRemove(args) {
+  const id = (args?.id || "").trim();
+  if (!id) return { success: false, error: "id required" };
+  const config = loadConfig();
+  const removed = (config.workspaces || []).find((w) => w.id === id);
+  const result = removeWorkspaceEntry(config, id);
+  if ("error" in result) return { success: false, error: result.error };
+  let cfg = result.config;
+  if (removed) {
+    cfg = removeActivityForPath(cfg, removed.path);
+  }
+  saveConfig(cfg);
+  const state = getWorkspaceState(cfg);
+  return { success: true, removedId: id, ...state, activity: getWorkspaceActivity(cfg, 25) };
+}
+function handleWorkspaceSetDefault(args) {
+  const clear = args?.clear === true || args?.id === null || args?.id === "";
+  if (clear) {
+    const config2 = loadConfig();
+    const result2 = setDefaultWorkspaceId(config2, null);
+    if ("error" in result2) return { success: false, error: result2.error };
+    saveConfig(result2.config);
+    const state2 = getWorkspaceState(result2.config);
+    return {
+      success: true,
+      ...state2,
+      activity: getWorkspaceActivity(result2.config, 25)
+    };
+  }
+  const pathArg = args?.path != null && String(args.path).trim() ? String(args.path).trim() : "";
+  const idArg = args?.id !== void 0 && args?.id !== null && String(args.id).trim() ? String(args.id).trim() : "";
+  if (!pathArg && !idArg) {
+    return { success: false, error: "id or path required (or clear: true)" };
+  }
+  let config = loadConfig();
+  let nextId;
+  if (pathArg) {
+    let w = findWorkspaceByPath(config, pathArg);
+    if (!w) {
+      const add = addWorkspaceEntry(config, pathArg);
+      if ("error" in add) return { success: false, error: add.error };
+      config = add.config;
+      w = add.entry;
+    }
+    nextId = w.id;
+  } else {
+    nextId = idArg;
+  }
+  const result = setDefaultWorkspaceId(config, nextId);
+  if ("error" in result) return { success: false, error: result.error };
+  let out = result.config;
+  const ap = getDefaultWorkspacePath(out);
+  if (ap) {
+    out = appendWorkspaceActivity(out, ap, { kind: "default" });
+  }
+  saveConfig(out);
+  const state = getWorkspaceState(out);
+  return { success: true, ...state, activity: getWorkspaceActivity(out, 25) };
+}
+
 // src/commands/handler.ts
+init_workspaces();
 var DaemonCommandHandler = class {
   _ctx;
   _agentStream = null;
@@ -3950,6 +4365,9 @@ var DaemonCommandHandler = class {
   }
   /** Extract ideType from _targetInstance */
   extractIdeType(args) {
+    if (args?.ideType && this._ctx.cdpManagers.has(args.ideType)) {
+      return args.ideType;
+    }
     if (args?._targetInstance) {
       let raw = args._targetInstance;
       const ideMatch = raw.match(/:ide:(.+)$/);
@@ -3961,8 +4379,19 @@ var DaemonCommandHandler = class {
       if (this._ctx.instanceIdMap?.has(raw)) {
         return this._ctx.instanceIdMap.get(raw);
       }
+      if (this._ctx.cdpManagers.has(raw)) {
+        return raw;
+      }
+      if (!ideMatch && !cliMatch && !acpMatch) {
+        for (const [key, mgr] of this._ctx.cdpManagers.entries()) {
+          if (mgr.isConnected) return key;
+        }
+      }
       const lastUnderscore = raw.lastIndexOf("_");
-      if (lastUnderscore > 0) return raw.substring(0, lastUnderscore);
+      if (lastUnderscore > 0) {
+        const stripped = raw.substring(0, lastUnderscore);
+        if (this._ctx.cdpManagers.has(stripped)) return stripped;
+      }
       return raw;
     }
     return void 0;
@@ -4058,6 +4487,19 @@ var DaemonCommandHandler = class {
         return { success: false, error: `${cmd} requires bridge-extension (removed)` };
       case "get_recent_workspaces":
         return this.handleGetRecentWorkspaces(args);
+      case "get_cli_history": {
+        const config = loadConfig();
+        return { success: true, history: config.cliHistory || [] };
+      }
+      case "workspace_list":
+        return handleWorkspaceList();
+      case "workspace_add":
+        return handleWorkspaceAdd(args);
+      case "workspace_remove":
+        return handleWorkspaceRemove(args);
+      case "workspace_set_default":
+      case "workspace_set_active":
+        return handleWorkspaceSetDefault(args);
       // ─── Script manage ───────────────────
       case "refresh_scripts":
         return this.handleRefreshScripts(args);
@@ -4107,10 +4549,18 @@ var DaemonCommandHandler = class {
     }
   }
   // ─── Misc (kept in handler — too small to extract) ───────
-  async handleGetRecentWorkspaces(args) {
+  async handleGetRecentWorkspaces(_args) {
     const config = loadConfig();
     const cliRecent = config.recentCliWorkspaces || [];
-    return { success: true, result: cliRecent };
+    const ws = getWorkspaceState(config);
+    return {
+      success: true,
+      result: cliRecent,
+      workspaces: ws.workspaces,
+      defaultWorkspaceId: ws.defaultWorkspaceId,
+      defaultWorkspacePath: ws.defaultWorkspacePath,
+      activity: getWorkspaceActivity(config, 25)
+    };
   }
   async handleRefreshScripts(_args) {
     if (this._ctx.providerLoader) {
@@ -4122,15 +4572,15 @@ var DaemonCommandHandler = class {
 };
 
 // src/launch.ts
-var import_child_process3 = require("child_process");
+var import_child_process4 = require("child_process");
 var net = __toESM(require("net"));
-var os6 = __toESM(require("os"));
-var path5 = __toESM(require("path"));
+var os8 = __toESM(require("os"));
+var path7 = __toESM(require("path"));
 
 // src/providers/provider-loader.ts
-var fs4 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
-var os5 = __toESM(require("os"));
+var fs5 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
+var os7 = __toESM(require("os"));
 var ProviderLoader = class _ProviderLoader {
   providers = /* @__PURE__ */ new Map();
   builtinDirs;
@@ -4150,10 +4600,10 @@ var ProviderLoader = class _ProviderLoader {
     if (options?.builtinDir) {
       this.builtinDirs = Array.isArray(options.builtinDir) ? options.builtinDir : [options.builtinDir];
     } else {
-      this.builtinDirs = [path4.resolve(__dirname, "../providers/_builtin")];
+      this.builtinDirs = [path6.resolve(__dirname, "../providers/_builtin")];
     }
-    this.userDir = options?.userDir || path4.join(os5.homedir(), ".adhdev", "providers");
-    this.upstreamDir = path4.join(this.userDir, ".upstream");
+    this.userDir = options?.userDir || path6.join(os7.homedir(), ".adhdev", "providers");
+    this.upstreamDir = path6.join(this.userDir, ".upstream");
     this.logFn = options?.logFn || LOG.forComponent("Provider").asLogFn();
   }
   log(msg) {
@@ -4171,19 +4621,19 @@ var ProviderLoader = class _ProviderLoader {
     this.providers.clear();
     let builtinCount = 0;
     for (const dir of this.builtinDirs) {
-      if (fs4.existsSync(dir)) {
+      if (fs5.existsSync(dir)) {
         builtinCount += this.loadDir(dir);
       }
     }
     this.log(`Loaded ${builtinCount} builtin providers`);
     let upstreamCount = 0;
-    if (fs4.existsSync(this.upstreamDir)) {
+    if (fs5.existsSync(this.upstreamDir)) {
       upstreamCount = this.loadDir(this.upstreamDir);
       if (upstreamCount > 0) {
         this.log(`Loaded ${upstreamCount} upstream providers (auto-updated)`);
       }
     }
-    if (fs4.existsSync(this.userDir)) {
+    if (fs5.existsSync(this.userDir)) {
       const userCount = this.loadDir(this.userDir, [".upstream"]);
       if (userCount > 0) {
         this.log(`Loaded ${userCount} user custom providers (never auto-updated)`);
@@ -4487,15 +4937,15 @@ var ProviderLoader = class _ProviderLoader {
       this.log(`  [loadScriptsFromDir] ${type}: providerDir not found`);
       return null;
     }
-    const dir = path4.join(providerDir, scriptDir);
-    if (!fs4.existsSync(dir)) {
+    const dir = path6.join(providerDir, scriptDir);
+    if (!fs5.existsSync(dir)) {
       this.log(`  [loadScriptsFromDir] ${type}: dir not found: ${dir}`);
       return null;
     }
     const cached = this.scriptsCache.get(dir);
     if (cached) return cached;
-    const scriptsJs = path4.join(dir, "scripts.js");
-    if (fs4.existsSync(scriptsJs)) {
+    const scriptsJs = path6.join(dir, "scripts.js");
+    if (fs5.existsSync(scriptsJs)) {
       try {
         delete require.cache[require.resolve(scriptsJs)];
         const loaded = require(scriptsJs);
@@ -4517,15 +4967,15 @@ var ProviderLoader = class _ProviderLoader {
   watch() {
     this.stopWatch();
     const watchDir = (dir) => {
-      if (!fs4.existsSync(dir)) {
+      if (!fs5.existsSync(dir)) {
         try {
-          fs4.mkdirSync(dir, { recursive: true });
+          fs5.mkdirSync(dir, { recursive: true });
         } catch {
           return;
         }
       }
       try {
-        const watcher = fs4.watch(dir, { recursive: true }, (event, filename) => {
+        const watcher = fs5.watch(dir, { recursive: true }, (event, filename) => {
           if (filename?.endsWith(".js") || filename?.endsWith(".json")) {
             this.log(`File changed: ${filename}, reloading...`);
             this.loadAll();
@@ -4575,13 +5025,13 @@ var ProviderLoader = class _ProviderLoader {
   */
   async fetchLatest() {
     const https = require("https");
-    const { execSync: execSync6 } = require("child_process");
-    const metaPath = path4.join(this.upstreamDir, _ProviderLoader.META_FILE);
+    const { execSync: execSync7 } = require("child_process");
+    const metaPath = path6.join(this.upstreamDir, _ProviderLoader.META_FILE);
     let prevEtag = "";
     let prevTimestamp = 0;
     try {
-      if (fs4.existsSync(metaPath)) {
-        const meta = JSON.parse(fs4.readFileSync(metaPath, "utf-8"));
+      if (fs5.existsSync(metaPath)) {
+        const meta = JSON.parse(fs5.readFileSync(metaPath, "utf-8"));
         prevEtag = meta.etag || "";
         prevTimestamp = meta.timestamp || 0;
       }
@@ -4593,7 +5043,7 @@ var ProviderLoader = class _ProviderLoader {
       return { updated: false };
     }
     try {
-      const etag = await new Promise((resolve5, reject) => {
+      const etag = await new Promise((resolve7, reject) => {
         const options = {
           method: "HEAD",
           hostname: "github.com",
@@ -4611,7 +5061,7 @@ var ProviderLoader = class _ProviderLoader {
               headers: { "User-Agent": "adhdev-launcher" },
               timeout: 1e4
             }, (res2) => {
-              resolve5(res2.headers.etag || res2.headers["last-modified"] || "");
+              resolve7(res2.headers.etag || res2.headers["last-modified"] || "");
             });
             req2.on("error", reject);
             req2.on("timeout", () => {
@@ -4620,7 +5070,7 @@ var ProviderLoader = class _ProviderLoader {
             });
             req2.end();
           } else {
-            resolve5(res.headers.etag || res.headers["last-modified"] || "");
+            resolve7(res.headers.etag || res.headers["last-modified"] || "");
           }
         });
         req.on("error", reject);
@@ -4636,39 +5086,39 @@ var ProviderLoader = class _ProviderLoader {
         return { updated: false };
       }
       this.log("Downloading latest providers from GitHub...");
-      const tmpTar = path4.join(os5.tmpdir(), `adhdev-providers-${Date.now()}.tar.gz`);
-      const tmpExtract = path4.join(os5.tmpdir(), `adhdev-providers-extract-${Date.now()}`);
+      const tmpTar = path6.join(os7.tmpdir(), `adhdev-providers-${Date.now()}.tar.gz`);
+      const tmpExtract = path6.join(os7.tmpdir(), `adhdev-providers-extract-${Date.now()}`);
       await this.downloadFile(_ProviderLoader.GITHUB_TARBALL_URL, tmpTar);
-      fs4.mkdirSync(tmpExtract, { recursive: true });
-      execSync6(`tar -xzf "${tmpTar}" -C "${tmpExtract}"`, { timeout: 3e4 });
-      const extracted = fs4.readdirSync(tmpExtract);
+      fs5.mkdirSync(tmpExtract, { recursive: true });
+      execSync7(`tar -xzf "${tmpTar}" -C "${tmpExtract}"`, { timeout: 3e4 });
+      const extracted = fs5.readdirSync(tmpExtract);
       const rootDir = extracted.find(
-        (d) => fs4.statSync(path4.join(tmpExtract, d)).isDirectory() && d.startsWith("adhdev-providers")
+        (d) => fs5.statSync(path6.join(tmpExtract, d)).isDirectory() && d.startsWith("adhdev-providers")
       );
       if (!rootDir) throw new Error("Unexpected tarball structure");
-      const sourceDir = path4.join(tmpExtract, rootDir);
+      const sourceDir = path6.join(tmpExtract, rootDir);
       const backupDir = this.upstreamDir + ".bak";
-      if (fs4.existsSync(this.upstreamDir)) {
-        if (fs4.existsSync(backupDir)) fs4.rmSync(backupDir, { recursive: true, force: true });
-        fs4.renameSync(this.upstreamDir, backupDir);
+      if (fs5.existsSync(this.upstreamDir)) {
+        if (fs5.existsSync(backupDir)) fs5.rmSync(backupDir, { recursive: true, force: true });
+        fs5.renameSync(this.upstreamDir, backupDir);
       }
       try {
         this.copyDirRecursive(sourceDir, this.upstreamDir);
         this.writeMeta(metaPath, etag || `ts-${Date.now()}`, Date.now());
-        if (fs4.existsSync(backupDir)) fs4.rmSync(backupDir, { recursive: true, force: true });
+        if (fs5.existsSync(backupDir)) fs5.rmSync(backupDir, { recursive: true, force: true });
       } catch (e) {
-        if (fs4.existsSync(backupDir)) {
-          if (fs4.existsSync(this.upstreamDir)) fs4.rmSync(this.upstreamDir, { recursive: true, force: true });
-          fs4.renameSync(backupDir, this.upstreamDir);
+        if (fs5.existsSync(backupDir)) {
+          if (fs5.existsSync(this.upstreamDir)) fs5.rmSync(this.upstreamDir, { recursive: true, force: true });
+          fs5.renameSync(backupDir, this.upstreamDir);
         }
         throw e;
       }
       try {
-        fs4.rmSync(tmpTar, { force: true });
+        fs5.rmSync(tmpTar, { force: true });
       } catch {
       }
       try {
-        fs4.rmSync(tmpExtract, { recursive: true, force: true });
+        fs5.rmSync(tmpExtract, { recursive: true, force: true });
       } catch {
       }
       const upstreamCount = this.countProviders(this.upstreamDir);
@@ -4684,7 +5134,7 @@ var ProviderLoader = class _ProviderLoader {
   downloadFile(url, destPath) {
     const https = require("https");
     const http3 = require("http");
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve7, reject) => {
       const doRequest = (reqUrl, redirectCount = 0) => {
         if (redirectCount > 5) {
           reject(new Error("Too many redirects"));
@@ -4700,11 +5150,11 @@ var ProviderLoader = class _ProviderLoader {
             reject(new Error(`HTTP ${res.statusCode}`));
             return;
           }
-          const ws = fs4.createWriteStream(destPath);
+          const ws = fs5.createWriteStream(destPath);
           res.pipe(ws);
           ws.on("finish", () => {
             ws.close();
-            resolve5();
+            resolve7();
           });
           ws.on("error", reject);
         });
@@ -4719,22 +5169,22 @@ var ProviderLoader = class _ProviderLoader {
   }
   /** Recursive directory copy */
   copyDirRecursive(src, dest) {
-    fs4.mkdirSync(dest, { recursive: true });
-    for (const entry of fs4.readdirSync(src, { withFileTypes: true })) {
-      const srcPath = path4.join(src, entry.name);
-      const destPath = path4.join(dest, entry.name);
+    fs5.mkdirSync(dest, { recursive: true });
+    for (const entry of fs5.readdirSync(src, { withFileTypes: true })) {
+      const srcPath = path6.join(src, entry.name);
+      const destPath = path6.join(dest, entry.name);
       if (entry.isDirectory()) {
         this.copyDirRecursive(srcPath, destPath);
       } else {
-        fs4.copyFileSync(srcPath, destPath);
+        fs5.copyFileSync(srcPath, destPath);
       }
     }
   }
   /** .meta.json save */
   writeMeta(metaPath, etag, timestamp) {
     try {
-      fs4.mkdirSync(path4.dirname(metaPath), { recursive: true });
-      fs4.writeFileSync(metaPath, JSON.stringify({
+      fs5.mkdirSync(path6.dirname(metaPath), { recursive: true });
+      fs5.writeFileSync(metaPath, JSON.stringify({
         etag,
         timestamp,
         lastCheck: new Date(timestamp).toISOString(),
@@ -4745,12 +5195,12 @@ var ProviderLoader = class _ProviderLoader {
   }
   /** Count provider files (provider.js or provider.json) */
   countProviders(dir) {
-    if (!fs4.existsSync(dir)) return 0;
+    if (!fs5.existsSync(dir)) return 0;
     let count = 0;
     const scan = (d) => {
       try {
-        for (const entry of fs4.readdirSync(d, { withFileTypes: true })) {
-          if (entry.isDirectory()) scan(path4.join(d, entry.name));
+        for (const entry of fs5.readdirSync(d, { withFileTypes: true })) {
+          if (entry.isDirectory()) scan(path6.join(d, entry.name));
           else if (entry.name === "provider.json") count++;
         }
       } catch {
@@ -4847,20 +5297,20 @@ var ProviderLoader = class _ProviderLoader {
     const cat = provider.category;
     const searchRoots = [this.userDir, this.upstreamDir, ...this.builtinDirs];
     for (const root of searchRoots) {
-      if (!fs4.existsSync(root)) continue;
-      for (const candidate of [path4.join(root, type), path4.join(root, cat, type)]) {
-        if (fs4.existsSync(path4.join(candidate, "provider.json"))) return candidate;
+      if (!fs5.existsSync(root)) continue;
+      for (const candidate of [path6.join(root, type), path6.join(root, cat, type)]) {
+        if (fs5.existsSync(path6.join(candidate, "provider.json"))) return candidate;
       }
-      const catDir = path4.join(root, cat);
-      if (fs4.existsSync(catDir)) {
+      const catDir = path6.join(root, cat);
+      if (fs5.existsSync(catDir)) {
         try {
-          for (const entry of fs4.readdirSync(catDir, { withFileTypes: true })) {
+          for (const entry of fs5.readdirSync(catDir, { withFileTypes: true })) {
             if (!entry.isDirectory()) continue;
-            const jsonPath = path4.join(catDir, entry.name, "provider.json");
-            if (fs4.existsSync(jsonPath)) {
+            const jsonPath = path6.join(catDir, entry.name, "provider.json");
+            if (fs5.existsSync(jsonPath)) {
               try {
-                const data = JSON.parse(fs4.readFileSync(jsonPath, "utf-8"));
-                if (data.type === type) return path4.join(catDir, entry.name);
+                const data = JSON.parse(fs5.readFileSync(jsonPath, "utf-8"));
+                if (data.type === type) return path6.join(catDir, entry.name);
               } catch {
               }
             }
@@ -4877,8 +5327,8 @@ var ProviderLoader = class _ProviderLoader {
    * (template substitution is NOT applied here — scripts.js handles that)
    */
   buildScriptWrappersFromDir(dir) {
-    const scriptsJs = path4.join(dir, "scripts.js");
-    if (fs4.existsSync(scriptsJs)) {
+    const scriptsJs = path6.join(dir, "scripts.js");
+    if (fs5.existsSync(scriptsJs)) {
       try {
         delete require.cache[require.resolve(scriptsJs)];
         return require(scriptsJs);
@@ -4888,13 +5338,13 @@ var ProviderLoader = class _ProviderLoader {
     const toCamel = (name) => name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
     const result = {};
     try {
-      for (const file of fs4.readdirSync(dir)) {
+      for (const file of fs5.readdirSync(dir)) {
         if (!file.endsWith(".js")) continue;
         const scriptName = toCamel(file.replace(".js", ""));
-        const filePath = path4.join(dir, file);
+        const filePath = path6.join(dir, file);
         result[scriptName] = (..._args) => {
           try {
-            return fs4.readFileSync(filePath, "utf-8");
+            return fs5.readFileSync(filePath, "utf-8");
           } catch {
             return "";
           }
@@ -4912,20 +5362,20 @@ var ProviderLoader = class _ProviderLoader {
    * Structure: dir/category/agent-name/provider.{json,js}
    */
   loadDir(dir, excludeDirs) {
-    if (!fs4.existsSync(dir)) return 0;
+    if (!fs5.existsSync(dir)) return 0;
     let count = 0;
     const scan = (d) => {
       let entries;
       try {
-        entries = fs4.readdirSync(d, { withFileTypes: true });
+        entries = fs5.readdirSync(d, { withFileTypes: true });
       } catch {
         return;
       }
       const hasJson = entries.some((e) => e.name === "provider.json");
       if (hasJson) {
-        const jsonPath = path4.join(d, "provider.json");
+        const jsonPath = path6.join(d, "provider.json");
         try {
-          const raw = fs4.readFileSync(jsonPath, "utf-8");
+          const raw = fs5.readFileSync(jsonPath, "utf-8");
           const mod = JSON.parse(raw);
           if (!mod.type || !mod.name || !mod.category) {
             this.log(`\u26A0 Invalid provider at ${jsonPath}: missing type/name/category`);
@@ -4936,8 +5386,8 @@ var ProviderLoader = class _ProviderLoader {
               delete mod.extensionIdPattern_flags;
             }
             const hasCompatibility = Array.isArray(mod.compatibility);
-            const scriptsPath = path4.join(d, "scripts.js");
-            if (!hasCompatibility && fs4.existsSync(scriptsPath)) {
+            const scriptsPath = path6.join(d, "scripts.js");
+            if (!hasCompatibility && fs5.existsSync(scriptsPath)) {
               try {
                 delete require.cache[require.resolve(scriptsPath)];
                 const scripts = require(scriptsPath);
@@ -4962,7 +5412,7 @@ var ProviderLoader = class _ProviderLoader {
           if (!entry.isDirectory()) continue;
           if (entry.name.startsWith("_") || entry.name.startsWith(".")) continue;
           if (excludeDirs && d === dir && excludeDirs.includes(entry.name)) continue;
-          scan(path4.join(d, entry.name));
+          scan(path6.join(d, entry.name));
         }
       }
     };
@@ -5041,17 +5491,17 @@ async function findFreePort(ports) {
   throw new Error("No free port found");
 }
 function checkPortFree(port) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve7) => {
     const server = net.createServer();
     server.unref();
-    server.on("error", () => resolve5(false));
+    server.on("error", () => resolve7(false));
     server.listen(port, "127.0.0.1", () => {
-      server.close(() => resolve5(true));
+      server.close(() => resolve7(true));
     });
   });
 }
 async function isCdpActive(port) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve7) => {
     const req = require("http").get(`http://127.0.0.1:${port}/json/version`, {
       timeout: 2e3
     }, (res) => {
@@ -5060,52 +5510,52 @@ async function isCdpActive(port) {
       res.on("end", () => {
         try {
           const info = JSON.parse(data);
-          resolve5(!!info["WebKit-Version"] || !!info["Browser"]);
+          resolve7(!!info["WebKit-Version"] || !!info["Browser"]);
         } catch {
-          resolve5(false);
+          resolve7(false);
         }
       });
     });
-    req.on("error", () => resolve5(false));
+    req.on("error", () => resolve7(false));
     req.on("timeout", () => {
       req.destroy();
-      resolve5(false);
+      resolve7(false);
     });
   });
 }
 async function killIdeProcess(ideId) {
-  const plat = os6.platform();
+  const plat = os8.platform();
   const appName = getMacAppIdentifiers()[ideId];
   const winProcesses = getWinProcessNames()[ideId];
   try {
     if (plat === "darwin" && appName) {
       try {
-        (0, import_child_process3.execSync)(`osascript -e 'tell application "${appName}" to quit' 2>/dev/null`, {
+        (0, import_child_process4.execSync)(`osascript -e 'tell application "${appName}" to quit' 2>/dev/null`, {
           timeout: 5e3
         });
       } catch {
         try {
-          (0, import_child_process3.execSync)(`pkill -f "${appName}" 2>/dev/null`);
+          (0, import_child_process4.execSync)(`pkill -f "${appName}" 2>/dev/null`);
         } catch {
         }
       }
     } else if (plat === "win32" && winProcesses) {
       for (const proc of winProcesses) {
         try {
-          (0, import_child_process3.execSync)(`taskkill /IM "${proc}" /F 2>nul`, { timeout: 5e3 });
+          (0, import_child_process4.execSync)(`taskkill /IM "${proc}" /F 2>nul`, { timeout: 5e3 });
         } catch {
         }
       }
       try {
         const exeName = winProcesses[0].replace(".exe", "");
-        (0, import_child_process3.execSync)(`powershell -Command "Get-Process -Name '${exeName}' -ErrorAction SilentlyContinue | Stop-Process -Force"`, {
+        (0, import_child_process4.execSync)(`powershell -Command "Get-Process -Name '${exeName}' -ErrorAction SilentlyContinue | Stop-Process -Force"`, {
           timeout: 1e4
         });
       } catch {
       }
     } else {
       try {
-        (0, import_child_process3.execSync)(`pkill -f "${ideId}" 2>/dev/null`);
+        (0, import_child_process4.execSync)(`pkill -f "${ideId}" 2>/dev/null`);
       } catch {
       }
     }
@@ -5115,13 +5565,13 @@ async function killIdeProcess(ideId) {
     }
     if (plat === "darwin" && appName) {
       try {
-        (0, import_child_process3.execSync)(`pkill -9 -f "${appName}" 2>/dev/null`);
+        (0, import_child_process4.execSync)(`pkill -9 -f "${appName}" 2>/dev/null`);
       } catch {
       }
     } else if (plat === "win32" && winProcesses) {
       for (const proc of winProcesses) {
         try {
-          (0, import_child_process3.execSync)(`taskkill /IM "${proc}" /F 2>nul`);
+          (0, import_child_process4.execSync)(`taskkill /IM "${proc}" /F 2>nul`);
         } catch {
         }
       }
@@ -5133,26 +5583,26 @@ async function killIdeProcess(ideId) {
   }
 }
 function isIdeRunning(ideId) {
-  const plat = os6.platform();
+  const plat = os8.platform();
   try {
     if (plat === "darwin") {
       const appName = getMacAppIdentifiers()[ideId];
       if (!appName) return false;
-      const result = (0, import_child_process3.execSync)(`pgrep -f "${appName}" 2>/dev/null`, { encoding: "utf-8" });
+      const result = (0, import_child_process4.execSync)(`pgrep -f "${appName}" 2>/dev/null`, { encoding: "utf-8" });
       return result.trim().length > 0;
     } else if (plat === "win32") {
       const winProcesses = getWinProcessNames()[ideId];
       if (!winProcesses) return false;
       for (const proc of winProcesses) {
         try {
-          const result = (0, import_child_process3.execSync)(`tasklist /FI "IMAGENAME eq ${proc}" /NH 2>nul`, { encoding: "utf-8" });
+          const result = (0, import_child_process4.execSync)(`tasklist /FI "IMAGENAME eq ${proc}" /NH 2>nul`, { encoding: "utf-8" });
           if (result.includes(proc)) return true;
         } catch {
         }
       }
       try {
         const exeName = winProcesses[0].replace(".exe", "");
-        const result = (0, import_child_process3.execSync)(
+        const result = (0, import_child_process4.execSync)(
           `powershell -Command "(Get-Process -Name '${exeName}' -ErrorAction SilentlyContinue).Count"`,
           { encoding: "utf-8", timeout: 5e3 }
         );
@@ -5161,7 +5611,7 @@ function isIdeRunning(ideId) {
       }
       return false;
     } else {
-      const result = (0, import_child_process3.execSync)(`pgrep -f "${ideId}" 2>/dev/null`, { encoding: "utf-8" });
+      const result = (0, import_child_process4.execSync)(`pgrep -f "${ideId}" 2>/dev/null`, { encoding: "utf-8" });
       return result.trim().length > 0;
     }
   } catch {
@@ -5169,12 +5619,12 @@ function isIdeRunning(ideId) {
   }
 }
 function detectCurrentWorkspace(ideId) {
-  const plat = os6.platform();
+  const plat = os8.platform();
   if (plat === "darwin") {
     try {
       const appName = getMacAppIdentifiers()[ideId];
       if (!appName) return void 0;
-      const result = (0, import_child_process3.execSync)(
+      const result = (0, import_child_process4.execSync)(
         `lsof -c "${appName}" 2>/dev/null | grep cwd | head -1 | awk '{print $NF}'`,
         { encoding: "utf-8", timeout: 3e3 }
       );
@@ -5184,17 +5634,17 @@ function detectCurrentWorkspace(ideId) {
     }
   } else if (plat === "win32") {
     try {
-      const fs9 = require("fs");
+      const fs10 = require("fs");
       const appNameMap = getMacAppIdentifiers();
       const appName = appNameMap[ideId];
       if (appName) {
-        const storagePath = path5.join(
-          process.env.APPDATA || path5.join(os6.homedir(), "AppData", "Roaming"),
+        const storagePath = path7.join(
+          process.env.APPDATA || path7.join(os8.homedir(), "AppData", "Roaming"),
           appName,
           "storage.json"
         );
-        if (fs9.existsSync(storagePath)) {
-          const data = JSON.parse(fs9.readFileSync(storagePath, "utf-8"));
+        if (fs10.existsSync(storagePath)) {
+          const data = JSON.parse(fs10.readFileSync(storagePath, "utf-8"));
           const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
           if (workspaces.length > 0) {
             const recent = workspaces[0];
@@ -5211,7 +5661,7 @@ function detectCurrentWorkspace(ideId) {
   return void 0;
 }
 async function launchWithCdp(options = {}) {
-  const platform7 = os6.platform();
+  const platform8 = os8.platform();
   let targetIde;
   const ides = await detectIDEs();
   if (options.ideId) {
@@ -5280,9 +5730,9 @@ async function launchWithCdp(options = {}) {
   }
   const port = await findFreePort(portPair);
   try {
-    if (platform7 === "darwin") {
+    if (platform8 === "darwin") {
       await launchMacOS(targetIde, port, workspace, options.newWindow);
-    } else if (platform7 === "win32") {
+    } else if (platform8 === "win32") {
       await launchWindows(targetIde, port, workspace, options.newWindow);
     } else {
       await launchLinux(targetIde, port, workspace, options.newWindow);
@@ -5322,9 +5772,9 @@ async function launchMacOS(ide, port, workspace, newWindow) {
   if (workspace) args.push(workspace);
   if (appName) {
     const openArgs = ["-a", appName, "--args", ...args];
-    (0, import_child_process3.spawn)("open", openArgs, { detached: true, stdio: "ignore" }).unref();
+    (0, import_child_process4.spawn)("open", openArgs, { detached: true, stdio: "ignore" }).unref();
   } else if (ide.cliCommand) {
-    (0, import_child_process3.spawn)(ide.cliCommand, args, { detached: true, stdio: "ignore" }).unref();
+    (0, import_child_process4.spawn)(ide.cliCommand, args, { detached: true, stdio: "ignore" }).unref();
   } else {
     throw new Error(`No app identifier or CLI for ${ide.displayName}`);
   }
@@ -5350,21 +5800,25 @@ async function launchLinux(ide, port, workspace, newWindow) {
   const args = ["--remote-debugging-port=" + port];
   if (newWindow) args.push("--new-window");
   if (workspace) args.push(workspace);
-  (0, import_child_process3.spawn)(cli, args, { detached: true, stdio: "ignore" }).unref();
+  (0, import_child_process4.spawn)(cli, args, { detached: true, stdio: "ignore" }).unref();
 }
 function getAvailableIdeIds() {
   return getProviderLoader().getAvailableIdeTypes();
 }
 
+// src/commands/router.ts
+init_config();
+init_workspaces();
+
 // src/logging/command-log.ts
-var fs5 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
-var os7 = __toESM(require("os"));
-var LOG_DIR2 = process.platform === "darwin" ? path6.join(os7.homedir(), "Library", "Logs", "adhdev") : path6.join(os7.homedir(), ".local", "share", "adhdev", "logs");
+var fs6 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
+var os9 = __toESM(require("os"));
+var LOG_DIR2 = process.platform === "darwin" ? path8.join(os9.homedir(), "Library", "Logs", "adhdev") : path8.join(os9.homedir(), ".local", "share", "adhdev", "logs");
 var MAX_FILE_SIZE = 5 * 1024 * 1024;
 var MAX_DAYS = 7;
 try {
-  fs5.mkdirSync(LOG_DIR2, { recursive: true });
+  fs6.mkdirSync(LOG_DIR2, { recursive: true });
 } catch {
 }
 var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
@@ -5398,19 +5852,19 @@ function getDateStr2() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
 var currentDate2 = getDateStr2();
-var currentFile = path6.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+var currentFile = path8.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
 var writeCount2 = 0;
 function checkRotation() {
   const today = getDateStr2();
   if (today !== currentDate2) {
     currentDate2 = today;
-    currentFile = path6.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
+    currentFile = path8.join(LOG_DIR2, `commands-${currentDate2}.jsonl`);
     cleanOldFiles();
   }
 }
 function cleanOldFiles() {
   try {
-    const files = fs5.readdirSync(LOG_DIR2).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
+    const files = fs6.readdirSync(LOG_DIR2).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
     const cutoff = /* @__PURE__ */ new Date();
     cutoff.setDate(cutoff.getDate() - MAX_DAYS);
     const cutoffStr = cutoff.toISOString().slice(0, 10);
@@ -5418,7 +5872,7 @@ function cleanOldFiles() {
       const dateMatch = file.match(/commands-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs5.unlinkSync(path6.join(LOG_DIR2, file));
+          fs6.unlinkSync(path8.join(LOG_DIR2, file));
         } catch {
         }
       }
@@ -5428,14 +5882,14 @@ function cleanOldFiles() {
 }
 function checkSize() {
   try {
-    const stat = fs5.statSync(currentFile);
+    const stat = fs6.statSync(currentFile);
     if (stat.size > MAX_FILE_SIZE) {
       const backup = currentFile.replace(".jsonl", ".1.jsonl");
       try {
-        fs5.unlinkSync(backup);
+        fs6.unlinkSync(backup);
       } catch {
       }
-      fs5.renameSync(currentFile, backup);
+      fs6.renameSync(currentFile, backup);
     }
   } catch {
   }
@@ -5460,14 +5914,14 @@ function logCommand(entry) {
       ...entry.error ? { err: entry.error } : {},
       ...entry.durationMs !== void 0 ? { ms: entry.durationMs } : {}
     });
-    fs5.appendFileSync(currentFile, line + "\n");
+    fs6.appendFileSync(currentFile, line + "\n");
   } catch {
   }
 }
 function getRecentCommands(count = 50) {
   try {
-    if (!fs5.existsSync(currentFile)) return [];
-    const content = fs5.readFileSync(currentFile, "utf-8");
+    if (!fs6.existsSync(currentFile)) return [];
+    const content = fs6.readFileSync(currentFile, "utf-8");
     const lines = content.trim().split("\n").filter(Boolean);
     return lines.slice(-count).map((line) => {
       try {
@@ -5492,7 +5946,7 @@ function getRecentCommands(count = 50) {
 cleanOldFiles();
 
 // src/commands/router.ts
-var fs6 = __toESM(require("fs"));
+var fs7 = __toESM(require("fs"));
 var CHAT_COMMANDS = [
   "send_chat",
   "new_chat",
@@ -5562,8 +6016,8 @@ var DaemonCommandRouter = class {
           if (logs.length > 0) {
             return { success: true, logs, totalBuffered: logs.length };
           }
-          if (fs6.existsSync(LOG_PATH)) {
-            const content = fs6.readFileSync(LOG_PATH, "utf-8");
+          if (fs7.existsSync(LOG_PATH)) {
+            const content = fs7.readFileSync(LOG_PATH, "utf-8");
             const allLines = content.split("\n");
             const recent = allLines.slice(-count).join("\n");
             return { success: true, logs: recent, totalLines: allLines.length };
@@ -5602,8 +6056,20 @@ var DaemonCommandRouter = class {
       }
       // ─── IDE launch + CDP connect ───
       case "launch_ide": {
-        const launchArgs = { ...args, ideId: args?.ideId || args?.ideType };
-        const ideKey = launchArgs.ideId;
+        const ideKey = args?.ideId || args?.ideType;
+        const resolvedWorkspace = resolveIdeLaunchWorkspace(
+          {
+            workspace: args?.workspace,
+            workspaceId: args?.workspaceId,
+            useDefaultWorkspace: args?.useDefaultWorkspace
+          },
+          loadConfig()
+        );
+        const launchArgs = {
+          ideId: ideKey,
+          workspace: resolvedWorkspace,
+          newWindow: args?.newWindow
+        };
         LOG.info("LaunchIDE", `target=${ideKey || "auto"}`);
         const result = await launchWithCdp(launchArgs);
         if (result.success && result.port && result.ideId && !this.deps.cdpManagers.has(result.ideId)) {
@@ -5620,6 +6086,15 @@ var DaemonCommandRouter = class {
           }
         }
         this.deps.onIdeConnected?.();
+        if (result.success && resolvedWorkspace) {
+          try {
+            saveConfig(appendWorkspaceActivity(loadConfig(), resolvedWorkspace, {
+              kind: "ide",
+              agentType: result.ideId
+            }));
+          } catch {
+          }
+        }
         return { success: result.success, ...result };
       }
       // ─── IDE detection ───
@@ -5627,6 +6102,12 @@ var DaemonCommandRouter = class {
         this.deps.detectedIdes.value = await detectIDEs();
         return { success: true, ides: this.deps.detectedIdes.value };
       }
+      // ─── Machine Settings ───
+      case "set_machine_nickname": {
+        const nickname = args?.nickname;
+        updateConfig({ machineNickname: nickname || null });
+        return { success: true };
+      }
     }
     return null;
   }
@@ -5663,8 +6144,9 @@ var DaemonCommandRouter = class {
 };
 
 // src/status/reporter.ts
-var os8 = __toESM(require("os"));
+var os10 = __toESM(require("os"));
 init_config();
+init_workspaces();
 var DaemonStatusReporter = class {
   deps;
   log;
@@ -5731,6 +6213,10 @@ var DaemonStatusReporter = class {
   // (agent-stream polling backward compat)
   updateAgentStreams(_ideType, _streams) {
   }
+  /** Reset P2P dedup hash — forces next send to transmit even if content unchanged */
+  resetP2PHash() {
+    this.lastP2PStatusHash = "";
+  }
   // ─── Core ────────────────────────────────────────
   ts() {
     return (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
@@ -5810,18 +6296,26 @@ var DaemonStatusReporter = class {
       acpConfigOptions: s.acpConfigOptions,
       acpModes: s.acpModes
     }));
+    const cfg = loadConfig();
+    const wsState = getWorkspaceState(cfg);
+    const memSnap = getHostMemorySnapshot();
     const payload = {
       daemonMode: true,
-      machineNickname: loadConfig().machineNickname || null,
+      machineNickname: cfg.machineNickname || null,
+      workspaces: wsState.workspaces,
+      defaultWorkspaceId: wsState.defaultWorkspaceId,
+      defaultWorkspacePath: wsState.defaultWorkspacePath,
+      workspaceActivity: getWorkspaceActivity(cfg, 15),
       machine: {
-        hostname: os8.hostname(),
-        platform: os8.platform(),
-        arch: os8.arch(),
-        cpus: os8.cpus().length,
-        totalMem: os8.totalmem(),
-        freeMem: os8.freemem(),
-        loadavg: os8.loadavg(),
-        uptime: os8.uptime()
+        hostname: os10.hostname(),
+        platform: os10.platform(),
+        arch: os10.arch(),
+        cpus: os10.cpus().length,
+        totalMem: memSnap.totalMem,
+        freeMem: memSnap.freeMem,
+        availableMem: memSnap.availableMem,
+        loadavg: os10.loadavg(),
+        uptime: os10.uptime()
       },
       managedIdes,
       managedClis,
@@ -5853,6 +6347,8 @@ var DaemonStatusReporter = class {
       const wsPayload = {
         daemonMode: true,
         machineNickname: payload.machineNickname,
+        defaultWorkspaceId: wsState.defaultWorkspaceId,
+        workspaceCount: (wsState.workspaces || []).length,
         // managedIdes: server only saves id, type, cdpConnected
         managedIdes: managedIdes.map((ide) => ({
           ideType: ide.ideType,
@@ -5883,7 +6379,7 @@ var DaemonStatusReporter = class {
   sendP2PPayload(payload) {
     const { timestamp: _ts, system: _sys, ...hashTarget } = payload;
     if (hashTarget.machine) {
-      const { freeMem: _f, loadavg: _l, uptime: _u, ...stableMachine } = hashTarget.machine;
+      const { freeMem: _f, availableMem: _a, loadavg: _l, uptime: _u, ...stableMachine } = hashTarget.machine;
       hashTarget.machine = stableMachine;
     }
     const h = this.simpleHash(JSON.stringify(hashTarget));
@@ -5905,17 +6401,34 @@ var DaemonStatusReporter = class {
 };
 
 // src/commands/cli-manager.ts
-var os10 = __toESM(require("os"));
-var path7 = __toESM(require("path"));
+var os12 = __toESM(require("os"));
+var path10 = __toESM(require("path"));
 var crypto4 = __toESM(require("crypto"));
 var import_chalk = __toESM(require("chalk"));
 
 // src/cli-adapters/provider-cli-adapter.ts
-var os9 = __toESM(require("os"));
-var import_child_process4 = require("child_process");
+var os11 = __toESM(require("os"));
+var path9 = __toESM(require("path"));
+var import_child_process5 = require("child_process");
 var pty;
 try {
   pty = require("node-pty");
+  if (os11.platform() !== "win32") {
+    try {
+      const fs10 = require("fs");
+      const ptyDir = path9.dirname(require.resolve("node-pty"));
+      const arch3 = os11.arch() === "arm64" ? "darwin-arm64" : "darwin-x64";
+      const helper = path9.join(ptyDir, "prebuilds", arch3, "spawn-helper");
+      if (fs10.existsSync(helper)) {
+        const stat = fs10.statSync(helper);
+        if (!(stat.mode & 73)) {
+          fs10.chmodSync(helper, stat.mode | 493);
+          LOG.info("CLI", "[node-pty] Fixed spawn-helper permissions");
+        }
+      }
+    } catch {
+    }
+  }
 } catch {
   LOG.error("CLI", "[ProviderCliAdapter] node-pty not found. Install: npm install node-pty@1.0.0");
 }
@@ -5923,21 +6436,125 @@ function stripAnsi(str) {
   return str.replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "").replace(/\x1B\][^\x07]*\x07/g, "").replace(/\x1B\][^\x1B]*\x1B\\/g, "");
 }
 function findBinary(name) {
-  const isWin = os9.platform() === "win32";
+  const isWin = os11.platform() === "win32";
   try {
     const cmd = isWin ? `where ${name}` : `which ${name}`;
-    return (0, import_child_process4.execSync)(cmd, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim().split("\n")[0].trim();
+    return (0, import_child_process5.execSync)(cmd, { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }).trim().split("\n")[0].trim();
   } catch {
     return isWin ? `${name}.cmd` : name;
   }
 }
+function isScriptBinary(binaryPath) {
+  if (!path9.isAbsolute(binaryPath)) return false;
+  try {
+    const fs10 = require("fs");
+    const resolved = fs10.realpathSync(binaryPath);
+    const head = Buffer.alloc(8);
+    const fd = fs10.openSync(resolved, "r");
+    fs10.readSync(fd, head, 0, 8, 0);
+    fs10.closeSync(fd);
+    let i = 0;
+    if (head[0] === 239 && head[1] === 187 && head[2] === 191) i = 3;
+    return head[i] === 35 && head[i + 1] === 33;
+  } catch {
+    return false;
+  }
+}
+function looksLikeMachOOrElf(filePath) {
+  if (!path9.isAbsolute(filePath)) return false;
+  try {
+    const fs10 = require("fs");
+    const resolved = fs10.realpathSync(filePath);
+    const buf = Buffer.alloc(8);
+    const fd = fs10.openSync(resolved, "r");
+    fs10.readSync(fd, buf, 0, 8, 0);
+    fs10.closeSync(fd);
+    let i = 0;
+    if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
+    const b = buf.subarray(i);
+    if (b.length < 4) return false;
+    if (b[0] === 127 && b[1] === 69 && b[2] === 76 && b[3] === 70) return true;
+    const le = b.readUInt32LE(0);
+    const be = b.readUInt32BE(0);
+    const magics = [4277009102, 4277009103, 3405691582, 3199925962];
+    return magics.some((m) => m === le || m === be);
+  } catch {
+    return false;
+  }
+}
+function shSingleQuote(arg) {
+  if (/^[a-zA-Z0-9@%_+=:,./-]+$/.test(arg)) return arg;
+  return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
+function parsePatternEntry(x) {
+  if (x instanceof RegExp) return x;
+  if (x && typeof x === "object" && typeof x.source === "string") {
+    try {
+      const s = x;
+      return new RegExp(s.source, s.flags || "");
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+function coercePatternArray(raw, fallbacks) {
+  if (!Array.isArray(raw)) return [...fallbacks];
+  const parsed = raw.map(parsePatternEntry).filter((r) => r != null);
+  return parsed.length > 0 ? parsed : [...fallbacks];
+}
+var FALLBACK_PROMPT = [
+  /Type your message/i,
+  /^>\s*$/m,
+  // '>' alone on its own line
+  /[›➤]\s*$/,
+  /for shortcuts/i,
+  /\?\s*for help/i,
+  /Press enter/i
+  // NOTE: removed /^[\s\u2500-\u257f]*>\s*$/m — the box-drawing char range is too wide and
+  // can match dialog-clearing ANSI output, causing false prompt detection in approval state.
+];
+var FALLBACK_GENERATING = [
+  /[\u2800-\u28ff]/,
+  // Braille spinner blocks (universal TUI)
+  /esc to (cancel|interrupt|stop)/i,
+  // Common TUI generation status line
+  /generating\.\.\./i,
+  /Claude is (?:thinking|processing|working)/i
+  // Specific Claude Code status
+];
+var FALLBACK_APPROVAL = [
+  /Allow\s+once/i,
+  /Always\s+allow/i,
+  /\(y\/n\)/i,
+  /\[Y\/n\]/i,
+  /Run\s+this\s+command/i
+  // NOTE: removed /Do you want to (?:run|execute|allow)/i — too broad, matches AI explanation
+  // text like "Do you want to allow this feature?" causing false approval notifications.
+];
+function defaultCleanOutput(raw, _lastUserInput) {
+  return stripAnsi(raw).trim();
+}
+function normalizeCliProviderForRuntime(raw) {
+  const patterns = raw?.patterns || {};
+  return {
+    ...raw,
+    patterns: {
+      prompt: coercePatternArray(patterns.prompt, FALLBACK_PROMPT),
+      generating: coercePatternArray(patterns.generating, FALLBACK_GENERATING),
+      approval: coercePatternArray(patterns.approval, FALLBACK_APPROVAL),
+      ready: coercePatternArray(patterns.ready, [])
+    },
+    cleanOutput: typeof raw?.cleanOutput === "function" ? raw.cleanOutput : defaultCleanOutput
+  };
+}
 var ProviderCliAdapter = class {
   constructor(provider, workingDir, extraArgs = []) {
     this.extraArgs = extraArgs;
-    this.provider = provider;
+    this.provider = normalizeCliProviderForRuntime(provider);
     this.cliType = provider.type;
     this.cliName = provider.name;
-    this.workingDir = workingDir.startsWith("~") ? workingDir.replace(/^~/, os9.homedir()) : workingDir;
+    this.workingDir = workingDir.startsWith("~") ? workingDir.replace(/^~/, os11.homedir()) : workingDir;
     const t = provider.timeouts || {};
     this.timeouts = {
       ptyFlush: t.ptyFlush ?? 50,
@@ -5974,6 +6591,11 @@ var ProviderCliAdapter = class {
   logBuffer = [];
   // Approval cooldown
   lastApprovalResolvedAt = 0;
+  // Approval state machine
+  approvalTransitionBuffer = "";
+  approvalExitTimeout = null;
+  // Resize redraw suppression
+  resizeSuppressUntil = 0;
   // Resolved timeouts (provider defaults + overrides)
   timeouts;
   // ─── Lifecycle ─────────────────────────────────
@@ -5995,20 +6617,25 @@ var ProviderCliAdapter = class {
     if (!pty) throw new Error("node-pty is not installed");
     const { spawn: spawnConfig } = this.provider;
     const binaryPath = findBinary(spawnConfig.command);
-    const isWin = os9.platform() === "win32";
+    const isWin = os11.platform() === "win32";
     const allArgs = [...spawnConfig.args, ...this.extraArgs];
     LOG.info("CLI", `[${this.cliType}] Spawning in ${this.workingDir}`);
     let shellCmd;
     let shellArgs;
-    if (spawnConfig.shell) {
+    const useShellUnix = !isWin && (!!spawnConfig.shell || !path9.isAbsolute(binaryPath) || isScriptBinary(binaryPath) || !looksLikeMachOOrElf(binaryPath));
+    const useShell = isWin ? !!spawnConfig.shell : useShellUnix;
+    if (useShell) {
+      if (!spawnConfig.shell && !isWin) {
+        LOG.info("CLI", `[${this.cliType}] Using login shell (script shim or non-native binary)`);
+      }
       shellCmd = isWin ? "cmd.exe" : process.env.SHELL || "/bin/zsh";
-      const fullCmd = [binaryPath, ...allArgs].join(" ");
+      const fullCmd = [binaryPath, ...allArgs].map(shSingleQuote).join(" ");
       shellArgs = isWin ? ["/c", fullCmd] : ["-l", "-c", fullCmd];
     } else {
       shellCmd = binaryPath;
       shellArgs = allArgs;
     }
-    this.ptyProcess = pty.spawn(shellCmd, shellArgs, {
+    const ptyOpts = {
       name: "xterm-256color",
       cols: 120,
       rows: 40,
@@ -6017,7 +6644,21 @@ var ProviderCliAdapter = class {
         ...process.env,
         ...spawnConfig.env
       }
-    });
+    };
+    try {
+      this.ptyProcess = pty.spawn(shellCmd, shellArgs, ptyOpts);
+    } catch (err) {
+      const msg = err?.message || String(err);
+      if (!isWin && !useShell && /posix_spawn|spawn/i.test(msg)) {
+        LOG.warn("CLI", `[${this.cliType}] Direct spawn failed (${msg}), retrying via login shell`);
+        shellCmd = process.env.SHELL || "/bin/zsh";
+        const fullCmd = [binaryPath, ...allArgs].map(shSingleQuote).join(" ");
+        shellArgs = ["-l", "-c", fullCmd];
+        this.ptyProcess = pty.spawn(shellCmd, shellArgs, ptyOpts);
+      } else {
+        throw err;
+      }
+    }
     this.ptyProcess.onData((data) => {
       this.handleOutput(data);
       if (this.onPtyDataCallback) {
@@ -6045,6 +6686,7 @@ var ProviderCliAdapter = class {
   }
   // ─── Output state machine ────────────────────────────
   handleOutput(rawData) {
+    if (Date.now() < this.resizeSuppressUntil) return;
     const cleanData = stripAnsi(rawData);
     const { patterns } = this.provider;
     if (cleanData.trim()) {
@@ -6077,30 +6719,55 @@ var ProviderCliAdapter = class {
     const hasApproval = patterns.approval.some((p) => p.test(this.recentOutputBuffer));
     if (hasApproval && this.currentStatus !== "waiting_approval") {
       if (this.lastApprovalResolvedAt && Date.now() - this.lastApprovalResolvedAt < this.timeouts.approvalCooldown) return;
+      const ctxLines = this.recentOutputBuffer.split("\n").map((l) => l.trim()).filter((l) => l && !/^[─═╭╮╰╯│]+$/.test(l));
       this.isWaitingForResponse = true;
       this.currentStatus = "waiting_approval";
       this.recentOutputBuffer = "";
-      const ctxLines = cleanData.split("\n").map((l) => l.trim()).filter((l) => l && !/^[─═╭╮╰╯│]+$/.test(l));
+      this.approvalTransitionBuffer = "";
       this.activeModal = {
         message: ctxLines.slice(-5).join(" ").slice(0, 200) || "Approval required",
         buttons: ["Allow once", "Always allow", "Deny"]
       };
       if (this.idleTimeout) clearTimeout(this.idleTimeout);
+      if (this.approvalExitTimeout) clearTimeout(this.approvalExitTimeout);
+      this.approvalExitTimeout = setTimeout(() => {
+        if (this.currentStatus === "waiting_approval") {
+          LOG.warn("CLI", `[${this.cliType}] Approval timeout \u2014 auto-exiting waiting_approval`);
+          this.activeModal = null;
+          this.lastApprovalResolvedAt = Date.now();
+          this.recentOutputBuffer = "";
+          this.approvalTransitionBuffer = "";
+          this.approvalExitTimeout = null;
+          this.currentStatus = this.isWaitingForResponse ? "generating" : "idle";
+          this.onStatusChange?.();
+        }
+      }, 6e4);
       this.onStatusChange?.();
       return;
     }
     if (this.currentStatus === "waiting_approval") {
-      const genResume = patterns.generating.some((p) => p.test(cleanData));
-      const promptResume = patterns.prompt.some((p) => p.test(cleanData));
+      this.approvalTransitionBuffer = (this.approvalTransitionBuffer + cleanData).slice(-500);
+      const genResume = patterns.generating.some((p) => p.test(this.approvalTransitionBuffer));
+      const promptResume = patterns.prompt.some((p) => p.test(this.approvalTransitionBuffer));
       if (genResume) {
+        if (this.approvalExitTimeout) {
+          clearTimeout(this.approvalExitTimeout);
+          this.approvalExitTimeout = null;
+        }
         this.currentStatus = "generating";
         this.activeModal = null;
         this.recentOutputBuffer = "";
+        this.approvalTransitionBuffer = "";
         this.lastApprovalResolvedAt = Date.now();
         this.onStatusChange?.();
       } else if (promptResume) {
+        if (this.approvalExitTimeout) {
+          clearTimeout(this.approvalExitTimeout);
+          this.approvalExitTimeout = null;
+        }
         this.activeModal = null;
         this.recentOutputBuffer = "";
+        this.approvalTransitionBuffer = "";
         this.lastApprovalResolvedAt = Date.now();
         this.finishResponse();
       }
@@ -6126,7 +6793,8 @@ var ProviderCliAdapter = class {
         this.onStatusChange?.();
         return;
       }
-      if (patterns.prompt.some((p) => p.test(this.responseBuffer))) {
+      const trailingLines = cleanData.split("\n").slice(-2).join("\n");
+      if (patterns.prompt.some((p) => p.test(trailingLines))) {
         this.finishResponse();
       } else {
         this.idleTimeout = setTimeout(() => {
@@ -6147,6 +6815,10 @@ var ProviderCliAdapter = class {
       clearTimeout(this.idleTimeout);
       this.idleTimeout = null;
     }
+    if (this.approvalExitTimeout) {
+      clearTimeout(this.approvalExitTimeout);
+      this.approvalExitTimeout = null;
+    }
     const lastUserText = this.messages.filter((m) => m.role === "user").pop()?.content;
     let response = this.provider.cleanOutput(this.responseBuffer, lastUserText);
     if (lastUserText && response) {
@@ -6196,6 +6868,10 @@ var ProviderCliAdapter = class {
     this.shutdown();
   }
   shutdown() {
+    if (this.approvalExitTimeout) {
+      clearTimeout(this.approvalExitTimeout);
+      this.approvalExitTimeout = null;
+    }
     if (this.ptyProcess) {
       this.ptyProcess.write("");
       setTimeout(() => {
@@ -6223,10 +6899,22 @@ var ProviderCliAdapter = class {
   writeRaw(data) {
     this.ptyProcess?.write(data);
   }
+  /**
+  * Resolve an approval modal by navigating to the button at `buttonIndex` and pressing Enter.
+  * Index 0 = first option (already selected by default — just Enter).
+  * Index N = press Arrow Down N times, then Enter.
+  */
+  resolveModal(buttonIndex) {
+    if (!this.ptyProcess || this.currentStatus !== "waiting_approval") return;
+    const DOWN = "\x1B[B";
+    const keys = DOWN.repeat(Math.max(0, buttonIndex)) + "\r";
+    this.ptyProcess.write(keys);
+  }
   resize(cols, rows) {
     if (this.ptyProcess) {
       try {
         this.ptyProcess.resize(cols, rows);
+        this.resizeSuppressUntil = Date.now() + 300;
       } catch {
       }
     }
@@ -6235,6 +6923,7 @@ var ProviderCliAdapter = class {
 
 // src/commands/cli-manager.ts
 init_config();
+init_workspaces();
 
 // src/providers/cli-provider-instance.ts
 var crypto3 = __toESM(require("crypto"));
@@ -6350,20 +7039,24 @@ var CliProviderInstance = class {
     const dirName = this.workingDir.split("/").filter(Boolean).pop() || "session";
     const chatTitle = `${this.provider.name} \xB7 ${dirName}`;
     if (newStatus !== this.lastStatus) {
+      LOG.info("CLI", `[${this.type}] status: ${this.lastStatus} \u2192 ${newStatus}`);
       if (this.lastStatus === "idle" && newStatus === "generating") {
         this.generatingStartedAt = now;
         this.pushEvent({ event: "agent:generating_started", chatTitle, timestamp: now });
       } else if (newStatus === "waiting_approval") {
         if (!this.generatingStartedAt) this.generatingStartedAt = now;
+        const modal = adapterStatus.activeModal;
+        LOG.info("CLI", `[${this.type}] approval modal: "${modal?.message?.slice(0, 80) ?? "none"}"`);
         this.pushEvent({
           event: "agent:waiting_approval",
           chatTitle,
           timestamp: now,
-          modalMessage: adapterStatus.activeModal?.message,
-          modalButtons: adapterStatus.activeModal?.buttons
+          modalMessage: modal?.message,
+          modalButtons: modal?.buttons
         });
       } else if (newStatus === "idle" && (this.lastStatus === "generating" || this.lastStatus === "waiting_approval")) {
         const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1e3) : 0;
+        LOG.info("CLI", `[${this.type}] completed in ${duration}s`);
         this.pushEvent({ event: "agent:generating_completed", chatTitle, duration, timestamp: now });
         this.generatingStartedAt = 0;
       } else if (newStatus === "stopped") {
@@ -6400,7 +7093,7 @@ var CliProviderInstance = class {
 
 // src/providers/acp-provider-instance.ts
 var import_stream = require("stream");
-var import_child_process5 = require("child_process");
+var import_child_process6 = require("child_process");
 var import_sdk = require("@agentclientprotocol/sdk");
 
 // src/providers/contracts.ts
@@ -6721,7 +7414,7 @@ var AcpProviderInstance = class {
     this.errorMessage = null;
     this.errorReason = null;
     this.stderrBuffer = [];
-    this.process = (0, import_child_process5.spawn)(command, args, {
+    this.process = (0, import_child_process6.spawn)(command, args, {
       cwd: this.workingDir,
       env,
       stdio: ["pipe", "pipe", "pipe"],
@@ -6825,13 +7518,13 @@ var AcpProviderInstance = class {
         }
         this.currentStatus = "waiting_approval";
         this.detectStatusTransition();
-        const approved = await new Promise((resolve5) => {
-          this.permissionResolvers.push(resolve5);
+        const approved = await new Promise((resolve7) => {
+          this.permissionResolvers.push(resolve7);
           setTimeout(() => {
-            const idx = this.permissionResolvers.indexOf(resolve5);
+            const idx = this.permissionResolvers.indexOf(resolve7);
             if (idx >= 0) {
               this.permissionResolvers.splice(idx, 1);
-              resolve5(false);
+              resolve7(false);
             }
           }, 3e5);
         });
@@ -7301,6 +7994,24 @@ var DaemonCliManager = class {
     const hash = require("crypto").createHash("md5").update(require("path").resolve(dir)).digest("hex").slice(0, 8);
     return `${cliType}_${hash}`;
   }
+  persistRecentDir(cliType, dir) {
+    try {
+      const normalizedType = this.providerLoader.resolveAlias(cliType);
+      const provider = this.providerLoader.getByAlias(cliType);
+      const actKind = provider?.category === "acp" ? "acp" : "cli";
+      let next = loadConfig();
+      console.log(import_chalk.default.cyan(`  \u{1F4C2} Saving recent workspace: ${dir}`));
+      const recent = next.recentCliWorkspaces || [];
+      if (!recent.includes(dir)) {
+        next = { ...next, recentCliWorkspaces: [dir, ...recent].slice(0, 10) };
+      }
+      next = appendWorkspaceActivity(next, dir, { kind: actKind, agentType: normalizedType });
+      saveConfig(next);
+      console.log(import_chalk.default.green(`  \u2713 Recent workspace saved: ${dir}`));
+    } catch (e) {
+      console.error(import_chalk.default.red(`  \u2717 Failed to save recent workspace: ${e}`));
+    }
+  }
   createAdapter(cliType, workingDir, cliArgs) {
     const normalizedType = this.providerLoader.resolveAlias(cliType);
     const provider = this.providerLoader.getMeta(normalizedType);
@@ -7312,8 +8023,9 @@ var DaemonCliManager = class {
   }
   // ─── Session start/management ──────────────────────────────
   async startSession(cliType, workingDir, cliArgs, initialModel) {
-    const trimmed = (workingDir || os10.homedir()).trim();
-    const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os10.homedir()) : path7.resolve(trimmed);
+    const trimmed = (workingDir || "").trim();
+    if (!trimmed) throw new Error("working directory required");
+    const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os12.homedir()) : path10.resolve(trimmed);
     const normalizedType = this.providerLoader.resolveAlias(cliType);
     const provider = this.providerLoader.getByAlias(cliType);
     const key = crypto4.randomUUID();
@@ -7323,8 +8035,8 @@ var DaemonCliManager = class {
       const spawnCmd = provider.spawn?.command;
       if (spawnCmd) {
         try {
-          const { execSync: execSync6 } = require("child_process");
-          execSync6(`which ${spawnCmd}`, { stdio: "ignore" });
+          const { execSync: execSync7 } = require("child_process");
+          execSync7(`which ${spawnCmd}`, { stdio: "ignore" });
         } catch {
           const installInfo = provider.install || `Install: check ${provider.displayName || provider.name} documentation`;
           throw new Error(
@@ -7391,18 +8103,52 @@ ${installInfo}`
     const instanceManager = this.deps.getInstanceManager();
     if (provider && instanceManager) {
       const cliInstance = new CliProviderInstance(provider, resolvedDir, cliArgs, key);
-      await instanceManager.addInstance(key, cliInstance, {
-        serverConn: this.deps.getServerConn(),
-        settings: {},
-        onPtyData: (data) => {
-          this.deps.getP2p()?.broadcastPtyOutput(key, data);
-        }
-      });
+      try {
+        await instanceManager.addInstance(key, cliInstance, {
+          serverConn: this.deps.getServerConn(),
+          settings: {},
+          onPtyData: (data) => {
+            this.deps.getP2p()?.broadcastPtyOutput(key, data);
+          }
+        });
+      } catch (spawnErr) {
+        LOG.error("CLI", `[${cliType}] Spawn failed: ${spawnErr?.message}`);
+        instanceManager.removeInstance(key);
+        throw new Error(`Failed to start ${cliInfo.displayName}: ${spawnErr?.message}`);
+      }
       this.adapters.set(key, cliInstance.getAdapter());
       console.log(import_chalk.default.green(`  \u2713 CLI started: ${cliInfo.displayName} v${cliInfo.version || "unknown"} in ${resolvedDir}`));
+      const checkStopped = setInterval(() => {
+        try {
+          const adapter = this.adapters.get(key);
+          if (!adapter) {
+            clearInterval(checkStopped);
+            return;
+          }
+          const status = adapter.getStatus?.();
+          if (status?.status === "stopped" || status?.status === "error") {
+            clearInterval(checkStopped);
+            setTimeout(() => {
+              if (this.adapters.has(key)) {
+                this.adapters.delete(key);
+                this.deps.removeAgentTracking(key);
+                instanceManager.removeInstance(key);
+                LOG.info("CLI", `\u{1F9F9} Auto-cleaned ${status.status} CLI: ${cliType}`);
+                this.deps.onStatusChange();
+              }
+            }, 5e3);
+          }
+        } catch {
+        }
+      }, 3e3);
     } else {
       const adapter = this.createAdapter(cliType, resolvedDir, cliArgs);
-      await adapter.spawn();
+      try {
+        await adapter.spawn();
+      } catch (spawnErr) {
+        LOG.error("CLI", `[${cliType}] Spawn failed: ${spawnErr?.message}`);
+        throw new Error(`Failed to start ${cliInfo.displayName}: ${spawnErr?.message}`);
+      }
       const serverConn = this.deps.getServerConn();
       if (serverConn && typeof adapter.setServerConn === "function") {
         adapter.setServerConn(serverConn);
@@ -7410,12 +8156,12 @@ ${installInfo}`
       adapter.setOnStatusChange(() => {
         this.deps.onStatusChange();
         const status = adapter.getStatus?.();
-        if (status?.status === "stopped") {
+        if (status?.status === "stopped" || status?.status === "error") {
           setTimeout(() => {
             if (this.adapters.get(key) === adapter) {
               this.adapters.delete(key);
               this.deps.removeAgentTracking(key);
-              console.log(import_chalk.default.yellow(`  \u{1F9F9} Auto-cleaned stopped CLI: ${adapter.cliType}`));
+              LOG.info("CLI", `\u{1F9F9} Auto-cleaned ${status.status} CLI: ${adapter.cliType}`);
               this.deps.onStatusChange();
             }
           }, 3e3);
@@ -7439,12 +8185,24 @@ ${installInfo}`
   async stopSession(key) {
     const adapter = this.adapters.get(key);
     if (adapter) {
-      adapter.shutdown();
+      try {
+        adapter.shutdown();
+      } catch (e) {
+        LOG.warn("CLI", `Shutdown error for ${adapter.cliType}: ${e?.message} (force-cleaning)`);
+      }
       this.adapters.delete(key);
       this.deps.removeAgentTracking(key);
       this.deps.getInstanceManager()?.removeInstance(key);
-      console.log(import_chalk.default.yellow(`  \u{1F6D1} CLI Agent stopped: ${adapter.cliType} in ${adapter.workingDir}`));
+      LOG.info("CLI", `\u{1F6D1} Agent stopped: ${adapter.cliType} in ${adapter.workingDir}`);
       this.deps.onStatusChange();
+    } else {
+      const im = this.deps.getInstanceManager();
+      if (im) {
+        im.removeInstance(key);
+        this.deps.removeAgentTracking(key);
+        LOG.warn("CLI", `\u{1F9F9} Force-removed orphan entry: ${key}`);
+        this.deps.onStatusChange();
+      }
     }
   }
   shutdownAll() {
@@ -7485,8 +8243,28 @@ ${installInfo}`
     switch (cmd) {
       case "launch_cli": {
         const cliType = args?.cliType;
-        const defaultedToHome = !args?.dir;
-        const dir = args?.dir || os10.homedir();
+        const config = loadConfig();
+        const resolved = resolveLaunchDirectory(
+          {
+            dir: args?.dir,
+            workspaceId: args?.workspaceId,
+            useDefaultWorkspace: args?.useDefaultWorkspace === true,
+            useHome: args?.useHome === true
+          },
+          config
+        );
+        if (!resolved.ok) {
+          const ws = getWorkspaceState(config);
+          return {
+            success: false,
+            error: resolved.message,
+            code: resolved.code,
+            workspaces: ws.workspaces,
+            defaultWorkspacePath: ws.defaultWorkspacePath
+          };
+        }
+        const dir = resolved.path;
+        const launchSource = resolved.source;
         if (!cliType) throw new Error("cliType required");
         await this.startSession(cliType, dir, args?.cliArgs, args?.initialModel);
         let newKey = null;
@@ -7495,19 +8273,8 @@ ${installInfo}`
             newKey = k;
           }
         }
-        try {
-          const config = loadConfig();
-          console.log(import_chalk.default.cyan(`  \u{1F4C2} Saving recent workspace: ${dir}`));
-          const recent = config.recentCliWorkspaces || [];
-          if (!recent.includes(dir)) {
-            const updated = [dir, ...recent].slice(0, 10);
-            saveConfig({ ...config, recentCliWorkspaces: updated });
-            console.log(import_chalk.default.green(`  \u2713 Recent workspace saved: ${dir}`));
-          }
-        } catch (e) {
-          console.error(import_chalk.default.red(`  \u2717 Failed to save recent workspace: ${e}`));
-        }
-        return { success: true, cliType, dir, id: newKey, defaultedToHome };
+        this.persistRecentDir(cliType, dir);
+        return { success: true, cliType, dir, id: newKey, launchSource };
       }
       case "stop_cli": {
         const cliType = args?.cliType;
@@ -7523,11 +8290,32 @@ ${installInfo}`
       }
       case "restart_session": {
         const cliType = args?.cliType || args?.agentType || args?.ideType;
-        const dir = args?.dir || process.cwd();
+        const cfg = loadConfig();
+        const rdir = resolveLaunchDirectory(
+          {
+            dir: args?.dir,
+            workspaceId: args?.workspaceId,
+            useDefaultWorkspace: args?.useDefaultWorkspace === true,
+            useHome: args?.useHome === true
+          },
+          cfg
+        );
+        if (!rdir.ok) {
+          const ws = getWorkspaceState(cfg);
+          return {
+            success: false,
+            error: rdir.message,
+            code: rdir.code,
+            workspaces: ws.workspaces,
+            defaultWorkspacePath: ws.defaultWorkspacePath
+          };
+        }
+        const dir = rdir.path;
         if (!cliType) throw new Error("cliType required");
         const found = this.findAdapter(cliType, { instanceKey: args?._targetInstance, dir });
         if (found) await this.stopSession(found.key);
         await this.startSession(cliType, dir);
+        this.persistRecentDir(cliType, dir);
         return { success: true, restarted: true };
       }
       case "agent_command": {
@@ -8167,12 +8955,12 @@ var ProviderInstanceManager = class {
 };
 
 // src/providers/version-archive.ts
-var fs7 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
-var os11 = __toESM(require("os"));
-var import_child_process6 = require("child_process");
+var fs8 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
+var os13 = __toESM(require("os"));
+var import_child_process7 = require("child_process");
 var import_os3 = require("os");
-var ARCHIVE_PATH = path8.join(os11.homedir(), ".adhdev", "version-history.json");
+var ARCHIVE_PATH = path11.join(os13.homedir(), ".adhdev", "version-history.json");
 var MAX_ENTRIES_PER_PROVIDER = 20;
 var VersionArchive = class {
   history = {};
@@ -8181,8 +8969,8 @@ var VersionArchive = class {
   }
   load() {
     try {
-      if (fs7.existsSync(ARCHIVE_PATH)) {
-        this.history = JSON.parse(fs7.readFileSync(ARCHIVE_PATH, "utf-8"));
+      if (fs8.existsSync(ARCHIVE_PATH)) {
+        this.history = JSON.parse(fs8.readFileSync(ARCHIVE_PATH, "utf-8"));
       }
     } catch {
       this.history = {};
@@ -8219,15 +9007,15 @@ var VersionArchive = class {
   }
   save() {
     try {
-      fs7.mkdirSync(path8.dirname(ARCHIVE_PATH), { recursive: true });
-      fs7.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
+      fs8.mkdirSync(path11.dirname(ARCHIVE_PATH), { recursive: true });
+      fs8.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
     } catch {
     }
   }
 };
 function runCommand(cmd, timeout = 1e4) {
   try {
-    return (0, import_child_process6.execSync)(cmd, {
+    return (0, import_child_process7.execSync)(cmd, {
       encoding: "utf-8",
       timeout,
       stdio: ["pipe", "pipe", "pipe"]
@@ -8259,19 +9047,19 @@ function getVersion(binary, versionCommand) {
 function checkPathExists2(paths) {
   for (const p of paths) {
     if (p.includes("*")) {
-      const home = os11.homedir();
-      const resolved = p.replace(/\*/g, home.split(path8.sep).pop() || "");
-      if (fs7.existsSync(resolved)) return resolved;
+      const home = os13.homedir();
+      const resolved = p.replace(/\*/g, home.split(path11.sep).pop() || "");
+      if (fs8.existsSync(resolved)) return resolved;
     } else {
-      if (fs7.existsSync(p)) return p;
+      if (fs8.existsSync(p)) return p;
     }
   }
   return null;
 }
 function getMacAppVersion(appPath) {
   if ((0, import_os3.platform)() !== "darwin" || !appPath.endsWith(".app")) return null;
-  const plistPath = path8.join(appPath, "Contents", "Info.plist");
-  if (!fs7.existsSync(plistPath)) return null;
+  const plistPath = path11.join(appPath, "Contents", "Info.plist");
+  if (!fs8.existsSync(plistPath)) return null;
   const raw = runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
   return raw || null;
 }
@@ -8296,8 +9084,8 @@ async function detectAllVersions(loader, archive) {
       const cliBin = provider.cli ? findBinary2(provider.cli) : null;
       let resolvedBin = cliBin;
       if (!resolvedBin && appPath && currentOs === "darwin") {
-        const bundled = path8.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
-        if (provider.cli && fs7.existsSync(bundled)) resolvedBin = bundled;
+        const bundled = path11.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
+        if (provider.cli && fs8.existsSync(bundled)) resolvedBin = bundled;
       }
       info.installed = !!(appPath || resolvedBin);
       info.path = appPath || null;
@@ -8336,9 +9124,9 @@ async function detectAllVersions(loader, archive) {
 
 // src/daemon/dev-server.ts
 var http2 = __toESM(require("http"));
-var fs8 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
-var os12 = __toESM(require("os"));
+var fs9 = __toESM(require("fs"));
+var path12 = __toESM(require("path"));
+var os14 = __toESM(require("os"));
 
 // src/daemon/scaffold-template.ts
 function generateFiles(type, name, category, opts = {}) {
@@ -8741,8 +9529,8 @@ var DevServer = class _DevServer {
   }
   getEndpointList() {
     return this.routes.map((r) => {
-      const path10 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
-      return `${r.method.padEnd(5)} ${path10}`;
+      const path13 = typeof r.pattern === "string" ? r.pattern : r.pattern.source.replace(/\\\//g, "/").replace(/\(\[.*?\]\+\)/g, ":type").replace(/[\^$]/g, "");
+      return `${r.method.padEnd(5)} ${path13}`;
     });
   }
   async start(port = DEV_SERVER_PORT) {
@@ -8773,15 +9561,15 @@ var DevServer = class _DevServer {
         this.json(res, 500, { error: e.message });
       }
     });
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve7, reject) => {
       this.server.listen(port, "127.0.0.1", () => {
         this.log(`Dev server listening on http://127.0.0.1:${port}`);
-        resolve5();
+        resolve7();
       });
       this.server.on("error", (e) => {
         if (e.code === "EADDRINUSE") {
           this.log(`Port ${port} in use, skipping dev server`);
-          resolve5();
+          resolve7();
         } else {
           reject(e);
         }
@@ -8864,20 +9652,20 @@ var DevServer = class _DevServer {
       child.stderr?.on("data", (d) => {
         stderr += d.toString().slice(0, 2e3);
       });
-      await new Promise((resolve5) => {
+      await new Promise((resolve7) => {
         const timer = setTimeout(() => {
           child.kill();
-          resolve5();
+          resolve7();
         }, 3e3);
         child.on("exit", () => {
           clearTimeout(timer);
-          resolve5();
+          resolve7();
         });
         child.stdout?.once("data", () => {
           setTimeout(() => {
             child.kill();
             clearTimeout(timer);
-            resolve5();
+            resolve7();
           }, 500);
         });
       });
@@ -9087,12 +9875,12 @@ var DevServer = class _DevServer {
   // ─── DevConsole SPA ───
   getConsoleDistDir() {
     const candidates = [
-      path9.resolve(__dirname, "../../web-devconsole/dist"),
-      path9.resolve(__dirname, "../../../web-devconsole/dist"),
-      path9.join(process.cwd(), "packages/web-devconsole/dist")
+      path12.resolve(__dirname, "../../web-devconsole/dist"),
+      path12.resolve(__dirname, "../../../web-devconsole/dist"),
+      path12.join(process.cwd(), "packages/web-devconsole/dist")
     ];
     for (const dir of candidates) {
-      if (fs8.existsSync(path9.join(dir, "index.html"))) return dir;
+      if (fs9.existsSync(path12.join(dir, "index.html"))) return dir;
     }
     return null;
   }
@@ -9102,9 +9890,9 @@ var DevServer = class _DevServer {
       this.json(res, 500, { error: "DevConsole not found. Run: npm run build -w packages/web-devconsole" });
       return;
     }
-    const htmlPath = path9.join(distDir, "index.html");
+    const htmlPath = path12.join(distDir, "index.html");
     try {
-      const html = fs8.readFileSync(htmlPath, "utf-8");
+      const html = fs9.readFileSync(htmlPath, "utf-8");
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
       res.end(html);
     } catch (e) {
@@ -9127,15 +9915,15 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: "Not found" });
       return;
     }
-    const safePath = path9.normalize(pathname).replace(/^\.\.\//, "");
-    const filePath = path9.join(distDir, safePath);
+    const safePath = path12.normalize(pathname).replace(/^\.\.\//, "");
+    const filePath = path12.join(distDir, safePath);
     if (!filePath.startsWith(distDir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
     }
     try {
-      const content = fs8.readFileSync(filePath);
-      const ext = path9.extname(filePath);
+      const content = fs9.readFileSync(filePath);
+      const ext = path12.extname(filePath);
       const contentType = _DevServer.MIME_MAP[ext] || "application/octet-stream";
       res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" });
       res.end(content);
@@ -9234,26 +10022,26 @@ var DevServer = class _DevServer {
     const provider = this.providerLoader.getMeta(type);
     if (!provider) return null;
     const cat = provider.category;
-    const builtinDir = this.providerLoader.builtinDir || path9.resolve(__dirname, "../providers/_builtin");
-    const userDir = path9.join(os12.homedir(), ".adhdev", "providers");
+    const builtinDir = this.providerLoader.builtinDir || path12.resolve(__dirname, "../providers/_builtin");
+    const userDir = path12.join(os14.homedir(), ".adhdev", "providers");
     const directCandidates = [
-      path9.join(userDir, type),
-      path9.join(builtinDir, cat, type),
-      path9.join(builtinDir, type)
+      path12.join(userDir, type),
+      path12.join(builtinDir, cat, type),
+      path12.join(builtinDir, type)
     ];
     for (const d of directCandidates) {
-      if (fs8.existsSync(path9.join(d, "provider.json"))) return d;
+      if (fs9.existsSync(path12.join(d, "provider.json"))) return d;
     }
-    const catDir = path9.join(builtinDir, cat);
-    if (fs8.existsSync(catDir)) {
+    const catDir = path12.join(builtinDir, cat);
+    if (fs9.existsSync(catDir)) {
       try {
-        for (const entry of fs8.readdirSync(catDir, { withFileTypes: true })) {
+        for (const entry of fs9.readdirSync(catDir, { withFileTypes: true })) {
           if (!entry.isDirectory()) continue;
-          const jsonPath = path9.join(catDir, entry.name, "provider.json");
-          if (fs8.existsSync(jsonPath)) {
+          const jsonPath = path12.join(catDir, entry.name, "provider.json");
+          if (fs9.existsSync(jsonPath)) {
             try {
-              const data = JSON.parse(fs8.readFileSync(jsonPath, "utf-8"));
-              if (data.type === type) return path9.join(catDir, entry.name);
+              const data = JSON.parse(fs9.readFileSync(jsonPath, "utf-8"));
+              if (data.type === type) return path12.join(catDir, entry.name);
             } catch {
             }
           }
@@ -9273,14 +10061,14 @@ var DevServer = class _DevServer {
     const files = [];
     const scan = (d, prefix) => {
       try {
-        for (const entry of fs8.readdirSync(d, { withFileTypes: true })) {
+        for (const entry of fs9.readdirSync(d, { withFileTypes: true })) {
           if (entry.name.startsWith(".") || entry.name.endsWith(".bak")) continue;
           const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
           if (entry.isDirectory()) {
             files.push({ path: rel, size: 0, type: "dir" });
-            scan(path9.join(d, entry.name), rel);
+            scan(path12.join(d, entry.name), rel);
           } else {
-            const stat = fs8.statSync(path9.join(d, entry.name));
+            const stat = fs9.statSync(path12.join(d, entry.name));
             files.push({ path: rel, size: stat.size, type: "file" });
           }
         }
@@ -9303,16 +10091,16 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider directory not found: ${type}` });
       return;
     }
-    const fullPath = path9.resolve(dir, path9.normalize(filePath));
+    const fullPath = path12.resolve(dir, path12.normalize(filePath));
     if (!fullPath.startsWith(dir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
     }
-    if (!fs8.existsSync(fullPath) || fs8.statSync(fullPath).isDirectory()) {
+    if (!fs9.existsSync(fullPath) || fs9.statSync(fullPath).isDirectory()) {
       this.json(res, 404, { error: `File not found: ${filePath}` });
       return;
     }
-    const content = fs8.readFileSync(fullPath, "utf-8");
+    const content = fs9.readFileSync(fullPath, "utf-8");
     this.json(res, 200, { type, path: filePath, content, lines: content.split("\n").length });
   }
   /** POST /api/providers/:type/file — write a file { path, content } */
@@ -9328,15 +10116,15 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider directory not found: ${type}` });
       return;
     }
-    const fullPath = path9.resolve(dir, path9.normalize(filePath));
+    const fullPath = path12.resolve(dir, path12.normalize(filePath));
     if (!fullPath.startsWith(dir)) {
       this.json(res, 403, { error: "Forbidden" });
       return;
     }
     try {
-      if (fs8.existsSync(fullPath)) fs8.copyFileSync(fullPath, fullPath + ".bak");
-      fs8.mkdirSync(path9.dirname(fullPath), { recursive: true });
-      fs8.writeFileSync(fullPath, content, "utf-8");
+      if (fs9.existsSync(fullPath)) fs9.copyFileSync(fullPath, fullPath + ".bak");
+      fs9.mkdirSync(path12.dirname(fullPath), { recursive: true });
+      fs9.writeFileSync(fullPath, content, "utf-8");
       this.log(`File saved: ${fullPath} (${content.length} chars)`);
       this.providerLoader.reload();
       this.json(res, 200, { saved: true, path: filePath, chars: content.length });
@@ -9352,9 +10140,9 @@ var DevServer = class _DevServer {
       return;
     }
     for (const name of ["scripts.js", "provider.json"]) {
-      const p = path9.join(dir, name);
-      if (fs8.existsSync(p)) {
-        const source = fs8.readFileSync(p, "utf-8");
+      const p = path12.join(dir, name);
+      if (fs9.existsSync(p)) {
+        const source = fs9.readFileSync(p, "utf-8");
         this.json(res, 200, { type, path: p, source, lines: source.split("\n").length });
         return;
       }
@@ -9373,11 +10161,11 @@ var DevServer = class _DevServer {
       this.json(res, 404, { error: `Provider not found: ${type}` });
       return;
     }
-    const target = fs8.existsSync(path9.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
-    const targetPath = path9.join(dir, target);
+    const target = fs9.existsSync(path12.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+    const targetPath = path12.join(dir, target);
     try {
-      if (fs8.existsSync(targetPath)) fs8.copyFileSync(targetPath, targetPath + ".bak");
-      fs8.writeFileSync(targetPath, source, "utf-8");
+      if (fs9.existsSync(targetPath)) fs9.copyFileSync(targetPath, targetPath + ".bak");
+      fs9.writeFileSync(targetPath, source, "utf-8");
       this.log(`Saved provider: ${targetPath} (${source.length} chars)`);
       this.providerLoader.reload();
       this.json(res, 200, { saved: true, path: targetPath, chars: source.length });
@@ -9392,18 +10180,18 @@ var DevServer = class _DevServer {
       return;
     }
     let scriptsPath = "";
-    const directScripts = path9.join(dir, "scripts.js");
-    if (fs8.existsSync(directScripts)) {
+    const directScripts = path12.join(dir, "scripts.js");
+    if (fs9.existsSync(directScripts)) {
       scriptsPath = directScripts;
     } else {
-      const scriptsDir = path9.join(dir, "scripts");
-      if (fs8.existsSync(scriptsDir)) {
-        const versions = fs8.readdirSync(scriptsDir).filter((d) => {
-          return fs8.statSync(path9.join(scriptsDir, d)).isDirectory();
+      const scriptsDir = path12.join(dir, "scripts");
+      if (fs9.existsSync(scriptsDir)) {
+        const versions = fs9.readdirSync(scriptsDir).filter((d) => {
+          return fs9.statSync(path12.join(scriptsDir, d)).isDirectory();
         }).sort().reverse();
         for (const ver of versions) {
-          const p = path9.join(scriptsDir, ver, "scripts.js");
-          if (fs8.existsSync(p)) {
+          const p = path12.join(scriptsDir, ver, "scripts.js");
+          if (fs9.existsSync(p)) {
             scriptsPath = p;
             break;
           }
@@ -9415,7 +10203,7 @@ var DevServer = class _DevServer {
       return;
     }
     try {
-      const source = fs8.readFileSync(scriptsPath, "utf-8");
+      const source = fs9.readFileSync(scriptsPath, "utf-8");
       const hints = {};
       const funcRegex = /module\.exports\.(\w+)\s*=\s*function\s+\w+\s*\(params\)/g;
       let match;
@@ -9559,14 +10347,14 @@ var DevServer = class _DevServer {
       child.stderr?.on("data", (d) => {
         stderr += d.toString();
       });
-      await new Promise((resolve5) => {
+      await new Promise((resolve7) => {
         const timer = setTimeout(() => {
           child.kill();
-          resolve5();
+          resolve7();
         }, timeout);
         child.on("exit", () => {
           clearTimeout(timer);
-          resolve5();
+          resolve7();
         });
       });
       const elapsed = Date.now() - start;
@@ -9616,26 +10404,26 @@ var DevServer = class _DevServer {
     }
     let targetDir;
     if (location === "user") {
-      targetDir = path9.join(os12.homedir(), ".adhdev", "providers", type);
+      targetDir = path12.join(os14.homedir(), ".adhdev", "providers", type);
     } else {
-      const builtinDir = path9.resolve(__dirname, "../providers/_builtin");
-      targetDir = path9.join(builtinDir, category, type);
+      const builtinDir = path12.resolve(__dirname, "../providers/_builtin");
+      targetDir = path12.join(builtinDir, category, type);
     }
-    const jsonPath = path9.join(targetDir, "provider.json");
-    if (fs8.existsSync(jsonPath)) {
+    const jsonPath = path12.join(targetDir, "provider.json");
+    if (fs9.existsSync(jsonPath)) {
       this.json(res, 409, { error: `Provider already exists at ${targetDir}`, path: targetDir });
       return;
     }
     try {
       const result = generateFiles(type, name, category, { cdpPorts, cli, processName, installPath, binary, extensionId, version });
-      fs8.mkdirSync(targetDir, { recursive: true });
-      fs8.writeFileSync(jsonPath, result["provider.json"], "utf-8");
+      fs9.mkdirSync(targetDir, { recursive: true });
+      fs9.writeFileSync(jsonPath, result["provider.json"], "utf-8");
       const createdFiles = ["provider.json"];
       if (result.files) {
         for (const [relPath, content] of Object.entries(result.files)) {
-          const fullPath = path9.join(targetDir, relPath);
-          fs8.mkdirSync(path9.dirname(fullPath), { recursive: true });
-          fs8.writeFileSync(fullPath, content, "utf-8");
+          const fullPath = path12.join(targetDir, relPath);
+          fs9.mkdirSync(path12.dirname(fullPath), { recursive: true });
+          fs9.writeFileSync(fullPath, content, "utf-8");
           createdFiles.push(relPath);
         }
       }
@@ -10470,24 +11258,24 @@ var DevServer = class _DevServer {
       }
       this.sendAutoImplSSE({ event: "progress", data: { function: "_init", status: "loading_reference", message: `\uB808\uD37C\uB7F0\uC2A4 \uC2A4\uD06C\uB9BD\uD2B8 \uB85C\uB4DC \uC911 (${reference})...` } });
       let referenceScripts = {};
-      const builtinDir = this.providerLoader.builtinDir || path9.resolve(__dirname, "../providers/_builtin");
-      const refDir = path9.join(builtinDir, "ide", reference);
-      if (fs8.existsSync(refDir)) {
-        const scriptsDir = path9.join(refDir, "scripts");
-        if (fs8.existsSync(scriptsDir)) {
-          const versions = fs8.readdirSync(scriptsDir).filter((d) => {
+      const builtinDir = this.providerLoader.builtinDir || path12.resolve(__dirname, "../providers/_builtin");
+      const refDir = path12.join(builtinDir, "ide", reference);
+      if (fs9.existsSync(refDir)) {
+        const scriptsDir = path12.join(refDir, "scripts");
+        if (fs9.existsSync(scriptsDir)) {
+          const versions = fs9.readdirSync(scriptsDir).filter((d) => {
             try {
-              return fs8.statSync(path9.join(scriptsDir, d)).isDirectory();
+              return fs9.statSync(path12.join(scriptsDir, d)).isDirectory();
             } catch {
               return false;
             }
           }).sort().reverse();
           if (versions.length > 0) {
-            const latestDir = path9.join(scriptsDir, versions[0]);
-            for (const file of fs8.readdirSync(latestDir)) {
+            const latestDir = path12.join(scriptsDir, versions[0]);
+            for (const file of fs9.readdirSync(latestDir)) {
               if (file.endsWith(".js")) {
                 try {
-                  referenceScripts[file] = fs8.readFileSync(path9.join(latestDir, file), "utf-8");
+                  referenceScripts[file] = fs9.readFileSync(path12.join(latestDir, file), "utf-8");
                 } catch {
                 }
               }
@@ -10496,16 +11284,16 @@ var DevServer = class _DevServer {
         }
       }
       const prompt = this.buildAutoImplPrompt(type, provider, providerDir, functions, domContext, referenceScripts);
-      const tmpDir = path9.join(os12.tmpdir(), "adhdev-autoimpl");
-      if (!fs8.existsSync(tmpDir)) fs8.mkdirSync(tmpDir, { recursive: true });
-      const promptFile = path9.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
-      fs8.writeFileSync(promptFile, prompt, "utf-8");
+      const tmpDir = path12.join(os14.tmpdir(), "adhdev-autoimpl");
+      if (!fs9.existsSync(tmpDir)) fs9.mkdirSync(tmpDir, { recursive: true });
+      const promptFile = path12.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
+      fs9.writeFileSync(promptFile, prompt, "utf-8");
       this.log(`Auto-implement prompt written to ${promptFile} (${prompt.length} chars)`);
       const agentProvider = this.providerLoader.resolve(agent) || this.providerLoader.getMeta(agent);
       const spawn3 = agentProvider?.spawn;
       if (!spawn3?.command) {
         try {
-          fs8.unlinkSync(promptFile);
+          fs9.unlinkSync(promptFile);
         } catch {
         }
         this.json(res, 400, { error: `Agent '${agent}' has no spawn config. Select a CLI provider with a spawn configuration.` });
@@ -10606,7 +11394,7 @@ var DevServer = class _DevServer {
           } catch {
           }
           try {
-            fs8.unlinkSync(promptFile);
+            fs9.unlinkSync(promptFile);
           } catch {
           }
           this.log(`Auto-implement (ACP) ${success ? "completed" : "failed"}: ${type} (exit: ${code})`);
@@ -10662,12 +11450,12 @@ var DevServer = class _DevServer {
       } else {
         args = [...baseArgs];
       }
-      const { execSync: execSync6 } = await import("child_process");
+      const { execSync: execSync7 } = await import("child_process");
       try {
-        execSync6(`which ${command}`, { stdio: "pipe" });
+        execSync7(`which ${command}`, { stdio: "pipe" });
       } catch {
         try {
-          fs8.unlinkSync(promptFile);
+          fs9.unlinkSync(promptFile);
         } catch {
         }
         this.json(res, 400, { error: `Agent binary '${command}' not found on PATH. Install it first: ${agentProvider?.install || "check provider docs"}` });
@@ -10723,7 +11511,7 @@ var DevServer = class _DevServer {
         } catch {
         }
         try {
-          fs8.unlinkSync(promptFile);
+          fs9.unlinkSync(promptFile);
         } catch {
         }
         this.log(`Auto-implement ${success ? "completed" : "failed"}: ${type} (exit: ${code})`);
@@ -10753,23 +11541,23 @@ var DevServer = class _DevServer {
     lines.push("## Current Target Files");
     lines.push("These are the files you need to EDIT. They contain TODO stubs \u2014 replace them with working implementations.");
     lines.push("");
-    const scriptsDir = path9.join(providerDir, "scripts");
-    if (fs8.existsSync(scriptsDir)) {
-      const versions = fs8.readdirSync(scriptsDir).filter((d) => {
+    const scriptsDir = path12.join(providerDir, "scripts");
+    if (fs9.existsSync(scriptsDir)) {
+      const versions = fs9.readdirSync(scriptsDir).filter((d) => {
         try {
-          return fs8.statSync(path9.join(scriptsDir, d)).isDirectory();
+          return fs9.statSync(path12.join(scriptsDir, d)).isDirectory();
         } catch {
           return false;
         }
       }).sort().reverse();
       if (versions.length > 0) {
-        const vDir = path9.join(scriptsDir, versions[0]);
+        const vDir = path12.join(scriptsDir, versions[0]);
         lines.push(`Scripts version directory: \`${vDir}\``);
         lines.push("");
-        for (const file of fs8.readdirSync(vDir)) {
+        for (const file of fs9.readdirSync(vDir)) {
           if (file.endsWith(".js")) {
             try {
-              const content = fs8.readFileSync(path9.join(vDir, file), "utf-8");
+              const content = fs9.readFileSync(path12.join(vDir, file), "utf-8");
               lines.push(`### \`${file}\``);
               lines.push("```javascript");
               lines.push(content);
@@ -10840,7 +11628,7 @@ var DevServer = class _DevServer {
     lines.push("## Required Return Format");
     lines.push("| Function | Return JSON |");
     lines.push("|---|---|");
-    lines.push("| readChat | `{ id, status, title, messages: [{role, content, index}], inputContent, activeModal }` |");
+    lines.push("| readChat | `{ id, status, title, messages: [{role, content, index, kind?, meta?}], inputContent, activeModal }` \u2014 optional `kind`: standard, thought, tool, terminal; optional `meta`: e.g. `{ label, isRunning }` for dashboard |");
     lines.push("| sendMessage | `{ sent: false, needsTypeAndSend: true, selector }` |");
     lines.push("| resolveAction | `{ resolved: true/false, clicked? }` |");
     lines.push("| listSessions | `{ sessions: [{ id, title, active, index }] }` |");
@@ -10964,14 +11752,14 @@ data: ${JSON.stringify(msg.data)}
     res.end(JSON.stringify(data, null, 2));
   }
   async readBody(req) {
-    return new Promise((resolve5) => {
+    return new Promise((resolve7) => {
       let body = "";
       req.on("data", (chunk) => body += chunk);
       req.on("end", () => {
         try {
-          resolve5(JSON.parse(body));
+          resolve7(JSON.parse(body));
         } catch {
-          resolve5({});
+          resolve7({});
         }
       });
     });
@@ -10979,7 +11767,7 @@ data: ${JSON.stringify(msg.data)}
 };
 
 // src/installer.ts
-var import_child_process7 = require("child_process");
+var import_child_process8 = require("child_process");
 var EXTENSION_CATALOG = [
   // AI Agent extensions
   {
@@ -11056,7 +11844,7 @@ var EXTENSION_CATALOG = [
 function isExtensionInstalled(ide, marketplaceId) {
   if (!ide.cliCommand) return false;
   try {
-    const result = (0, import_child_process7.execSync)(`"${ide.cliCommand}" --list-extensions`, {
+    const result = (0, import_child_process8.execSync)(`"${ide.cliCommand}" --list-extensions`, {
       encoding: "utf-8",
       timeout: 15e3,
       stdio: ["pipe", "pipe", "pipe"]
@@ -11093,12 +11881,12 @@ async function installExtension(ide, extension) {
       const res = await fetch(extension.vsixUrl);
       if (res.ok) {
         const buffer = Buffer.from(await res.arrayBuffer());
-        const fs9 = await import("fs");
-        fs9.writeFileSync(vsixPath, buffer);
-        return new Promise((resolve5) => {
+        const fs10 = await import("fs");
+        fs10.writeFileSync(vsixPath, buffer);
+        return new Promise((resolve7) => {
           const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
-          (0, import_child_process7.exec)(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {
-            resolve5({
+          (0, import_child_process8.exec)(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {
+            resolve7({
               extensionId: extension.id,
               marketplaceId: extension.marketplaceId,
               success: !error,
@@ -11111,11 +11899,11 @@ async function installExtension(ide, extension) {
     } catch (e) {
     }
   }
-  return new Promise((resolve5) => {
+  return new Promise((resolve7) => {
     const cmd = `"${ide.cliCommand}" --install-extension ${extension.marketplaceId} --force`;
-    (0, import_child_process7.exec)(cmd, { timeout: 6e4 }, (error, stdout, stderr) => {
+    (0, import_child_process8.exec)(cmd, { timeout: 6e4 }, (error, stdout, stderr) => {
       if (error) {
-        resolve5({
+        resolve7({
           extensionId: extension.id,
           marketplaceId: extension.marketplaceId,
           success: false,
@@ -11123,7 +11911,7 @@ async function installExtension(ide, extension) {
           error: stderr || error.message
         });
       } else {
-        resolve5({
+        resolve7({
           extensionId: extension.id,
           marketplaceId: extension.marketplaceId,
           success: true,
@@ -11150,7 +11938,7 @@ function launchIDE(ide, workspacePath) {
   if (!ide.cliCommand) return false;
   try {
     const args = workspacePath ? `"${workspacePath}"` : "";
-    (0, import_child_process7.exec)(`"${ide.cliCommand}" ${args}`, { timeout: 1e4 });
+    (0, import_child_process8.exec)(`"${ide.cliCommand}" ${args}`, { timeout: 1e4 });
     return true;
   } catch {
     return false;
@@ -11315,9 +12103,12 @@ async function shutdownDaemonComponents(components) {
   detectIDEs,
   getAIExtensions,
   getAvailableIdeIds,
+  getHostMemorySnapshot,
   getLogLevel,
   getRecentCommands,
   getRecentLogs,
+  getWorkspaceActivity,
+  getWorkspaceState,
   initDaemonComponents,
   installExtensions,
   installGlobalInterceptor,