npm - @adhdev/daemon-core - Versions diffs - 0.5.3 → 0.5.5 - Mend

@adhdev/daemon-core 0.5.3 → 0.5.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (43) hide show

package/dist/index.js CHANGED Viewed

@@ -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) {
@@ -3360,9 +3654,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 +3808,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 +3831,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 +3841,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 +4135,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 +4332,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 +4346,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 +4454,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 +4516,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 +4539,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 +4567,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 +4588,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 +4904,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 +4934,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 +4992,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 +5010,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 +5028,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 +5037,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 +5053,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 +5101,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 +5117,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 +5136,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 +5162,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 +5264,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 +5294,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 +5305,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 +5329,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 +5353,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 +5379,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 +5458,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 +5477,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 +5532,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 +5550,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 +5578,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 +5586,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 +5601,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 +5628,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 +5697,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 +5739,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 +5767,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 +5819,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 +5839,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 +5849,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 +5881,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 +5913,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 +5983,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 +6023,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 +6053,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 +6069,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 +6111,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 +6180,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 +6263,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 +6314,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 +6346,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 +6368,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 +6403,121 @@ 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*$/,
+  /[›➤]\s*$/,
+  /for shortcuts/i,
+  /\?\s*for help/i,
+  /Press enter/i,
+  /^[\s\u2500-\u257f]*>\s*$/m
+];
+var FALLBACK_GENERATING = [
+  /thinking/i,
+  /writing/i,
+  /Claude is/i,
+  /Opus|Sonnet|Haiku/i,
+  /[\u2800-\u28ff]/
+  // Braille spinner blocks
+];
+var FALLBACK_APPROVAL = [
+  /approve/i,
+  /Allow( once)?/i,
+  /\(y\/n\)/i,
+  /\[Y\/n\]/i,
+  /continue\?/i,
+  /Run this command/i
+];
+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,
@@ -5995,20 +6575,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 +6602,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) {
@@ -6235,6 +6834,7 @@ var ProviderCliAdapter = class {
 // src/commands/cli-manager.ts
 init_config();
+init_workspaces();
 // src/providers/cli-provider-instance.ts
 var crypto3 = __toESM(require("crypto"));
@@ -6400,7 +7000,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 +7321,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 +7425,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 +7901,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 +7930,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 +7942,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 +8010,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 +8063,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 +8092,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 +8150,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 +8180,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 +8197,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 +8862,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 +8876,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 +8914,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 +8954,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 +8991,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 +9031,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 +9436,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 +9468,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 +9559,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 +9782,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 +9797,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 +9822,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 +9929,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 +9968,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 +9998,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 +10023,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 +10047,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 +10068,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 +10087,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 +10110,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 +10254,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 +10311,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 +11165,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 +11191,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 +11301,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 +11357,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 +11418,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 +11448,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 +11535,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 +11659,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 +11674,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 +11751,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 +11788,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 +11806,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 +11818,7 @@ async function installExtension(ide, extension) {
           error: stderr || error.message
         });
       } else {
-        resolve5({
+        resolve7({
           extensionId: extension.id,
           marketplaceId: extension.marketplaceId,
           success: true,
@@ -11150,7 +11845,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 +12010,12 @@ async function shutdownDaemonComponents(components) {
   detectIDEs,
   getAIExtensions,
   getAvailableIdeIds,
+  getHostMemorySnapshot,
   getLogLevel,
   getRecentCommands,
   getRecentLogs,
+  getWorkspaceActivity,
+  getWorkspaceState,
   initDaemonComponents,
   installExtensions,
   installGlobalInterceptor,