adhdev 0.7.39 → 0.7.41

package/dist/cli/index.js

@@ -176,7 +176,8 @@ var init_config = __esm({
       workspaces: [],
       defaultWorkspaceId: null,
       recentActivity: [],
-      recentSessionReads: {},
+      sessionReads: {},
+      sessionReadMarkers: {},
       machineNickname: null,
       machineId: void 0,
       machineSecret: null,
@@ -389,18 +390,27 @@ function appendRecentActivity(config2, entry) {
 function getRecentActivity(config2, limit = 20) {
   return [...config2.recentActivity || []].sort((a, b2) => b2.lastUsedAt - a.lastUsedAt).slice(0, limit);
 }
-function getRecentSessionSeenAt(config2, recentKey) {
-  return config2.recentSessionReads?.[recentKey] || 0;
+function getSessionSeenAt(config2, sessionId) {
+  return config2.sessionReads?.[sessionId] || 0;
 }
-function markRecentSessionSeen(config2, recentKey, seenAt = Date.now()) {
-  const prev = config2.recentSessionReads || {};
-  const nextSeenAt = Math.max(prev[recentKey] || 0, seenAt);
+function getSessionSeenMarker(config2, sessionId) {
+  return config2.sessionReadMarkers?.[sessionId] || "";
+}
+function markSessionSeen(config2, sessionId, seenAt = Date.now(), completionMarker) {
+  const prev = config2.sessionReads || {};
+  const nextSeenAt = Math.max(prev[sessionId] || 0, seenAt);
+  const prevMarkers = config2.sessionReadMarkers || {};
+  const nextMarker = typeof completionMarker === "string" ? completionMarker : "";
   return {
     ...config2,
-    recentSessionReads: {
+    sessionReads: {
       ...prev,
-      [recentKey]: nextSeenAt
-    }
+      [sessionId]: nextSeenAt
+    },
+    sessionReadMarkers: nextMarker ? {
+      ...prevMarkers,
+      [sessionId]: nextMarker
+    } : prevMarkers
   };
 }
 var path2, MAX_ACTIVITY;
@@ -3591,6 +3601,8 @@ function buildCliSession(state) {
     runtimeWorkspaceLabel: state.runtime?.workspaceLabel,
     runtimeWriteOwner: state.runtime?.writeOwner || null,
     runtimeAttachedClients: state.runtime?.attachedClients || [],
+    launchMode: state.launchMode,
+    mode: state.mode,
     resume: state.resume,
     activeChat,
     capabilities: PTY_SESSION_CAPABILITIES,
@@ -8838,337 +8850,6 @@ var init_command_log = __esm({
   }
 });
 
-// ../../oss/packages/daemon-core/src/commands/router.ts
-var fs7, CHAT_COMMANDS, DaemonCommandRouter;
-var init_router = __esm({
-  "../../oss/packages/daemon-core/src/commands/router.ts"() {
-    "use strict";
-    init_manager();
-    init_setup();
-    init_launch();
-    init_config();
-    init_workspaces();
-    init_recent_activity();
-    init_ide_detector();
-    init_logger();
-    init_command_log();
-    init_logger();
-    fs7 = __toESM(require("fs"));
-    CHAT_COMMANDS = [
-      "send_chat",
-      "new_chat",
-      "switch_chat",
-      "set_mode",
-      "change_model"
-    ];
-    DaemonCommandRouter = class {
-      deps;
-      constructor(deps) {
-        this.deps = deps;
-      }
-      /**
-       * Unified command routing.
-       * Returns result for all commands:
-       *   1. Daemon-level commands (launch_ide, stop_ide, etc.)
-       *   2. CLI commands (launch_cli, stop_cli, agent_command)
-       *   3. DaemonCommandHandler delegation (CDP/agent-stream/file commands)
-       *
-       * @param cmd Command name
-       * @param args Command arguments
-       * @param source Log source ('ws' | 'p2p' | 'standalone' | etc.)
-       */
-      async execute(cmd, args, source = "unknown") {
-        const cmdStart = Date.now();
-        try {
-          const daemonResult = await this.executeDaemonCommand(cmd, args);
-          if (daemonResult) {
-            logCommand({ ts: (/* @__PURE__ */ new Date()).toISOString(), cmd, source, args, success: daemonResult.success, durationMs: Date.now() - cmdStart });
-            return daemonResult;
-          }
-          const handlerResult = await this.deps.commandHandler.handle(cmd, args);
-          logCommand({ ts: (/* @__PURE__ */ new Date()).toISOString(), cmd, source, args, success: handlerResult.success, durationMs: Date.now() - cmdStart });
-          if (CHAT_COMMANDS.includes(cmd) && this.deps.onPostChatCommand) {
-            this.deps.onPostChatCommand();
-          }
-          return handlerResult;
-        } catch (e) {
-          logCommand({ ts: (/* @__PURE__ */ new Date()).toISOString(), cmd, source, args, success: false, error: e.message, durationMs: Date.now() - cmdStart });
-          throw e;
-        }
-      }
-      // ─── Daemon-level command core ───────────────────
-      /**
-       * Daemon-level command execution (IDE start/stop/restart, CLI, detect, logs).
-       * Returns null if not handled at this level → caller delegates to CommandHandler.
-       */
-      async executeDaemonCommand(cmd, args) {
-        switch (cmd) {
-          // ─── CLI / ACP commands ───
-          case "launch_cli":
-          case "stop_cli":
-          case "agent_command": {
-            return this.deps.cliManager.handleCliCommand(cmd, args);
-          }
-          // ─── Logs ───
-          case "get_logs": {
-            const count = parseInt(args?.count) || parseInt(args?.lines) || 100;
-            const minLevel = args?.minLevel || "info";
-            const sinceTs = args?.since || 0;
-            try {
-              let logs = getRecentLogs(count, minLevel);
-              if (sinceTs > 0) {
-                logs = logs.filter((l) => l.ts > sinceTs);
-              }
-              if (logs.length > 0) {
-                return { success: true, logs, totalBuffered: logs.length };
-              }
-              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 };
-              }
-              return { success: true, logs: [], totalBuffered: 0 };
-            } catch (e) {
-              return { success: false, error: e.message };
-            }
-          }
-          // ─── restart_session: IDE / CLI / ACP unified ───
-          case "restart_session": {
-            const targetType = args?.cliType || args?.agentType || args?.ideType;
-            if (!targetType) throw new Error("cliType or ideType required");
-            const isIde = this.deps.cdpManagers.has(targetType) || this.deps.providerLoader.getMeta(targetType)?.category === "ide";
-            if (isIde) {
-              await this.stopIde(targetType, true);
-              const launchResult = await this.executeDaemonCommand("launch_ide", { ideType: targetType, enableCdp: true, workspace: args?.workspace });
-              return { success: true, restarted: true, ideType: targetType, launch: launchResult };
-            }
-            return this.deps.cliManager.handleCliCommand(cmd, args);
-          }
-          // ─── IDE stop ───
-          case "stop_ide": {
-            const ideType = args?.ideType;
-            if (!ideType) throw new Error("ideType required");
-            const killProcess = args?.killProcess !== false;
-            await this.stopIde(ideType, killProcess);
-            return { success: true, ideType, stopped: true, processKilled: killProcess };
-          }
-          // ─── IDE restart ───
-          case "restart_ide": {
-            const ideType = args?.ideType;
-            if (!ideType) throw new Error("ideType required");
-            await this.stopIde(ideType, true);
-            const launchResult = await this.executeDaemonCommand("launch_ide", { ideType, enableCdp: true, workspace: args?.workspace });
-            return { success: true, ideType, restarted: true, launch: launchResult };
-          }
-          // ─── IDE launch + CDP connect ───
-          case "launch_ide": {
-            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)) {
-              const logFn = this.deps.getCdpLogFn ? this.deps.getCdpLogFn(result.ideId) : LOG.forComponent(`CDP:${result.ideId}`).asLogFn();
-              const provider = this.deps.providerLoader.getMeta(result.ideId);
-              const manager = new DaemonCdpManager(result.port, logFn, void 0, provider?.targetFilter);
-              const connected = await manager.connect();
-              if (connected) {
-                registerExtensionProviders(this.deps.providerLoader, manager, result.ideId);
-                this.deps.cdpManagers.set(result.ideId, manager);
-                LOG.info("CDP", `Connected: ${result.ideId} (port ${result.port})`);
-                LOG.info("CDP", `${this.deps.cdpManagers.size} IDE(s) connected`);
-                this.deps.onCdpManagerCreated?.(result.ideId, manager);
-              }
-            }
-            this.deps.onIdeConnected?.();
-            if (result.success && resolvedWorkspace) {
-              try {
-                const next = appendRecentActivity(loadConfig(), {
-                  kind: "ide",
-                  providerType: result.ideId || ideKey,
-                  providerName: result.ideId || ideKey,
-                  workspace: resolvedWorkspace,
-                  title: result.ideId || ideKey
-                });
-                saveConfig(next);
-              } catch {
-              }
-            } else if (result.success && (result.ideId || ideKey)) {
-              try {
-                saveConfig(appendRecentActivity(loadConfig(), {
-                  kind: "ide",
-                  providerType: result.ideId || ideKey,
-                  providerName: result.ideId || ideKey,
-                  title: result.ideId || ideKey
-                }));
-              } catch {
-              }
-            }
-            return { success: result.success, ...result };
-          }
-          // ─── Detect IDEs ───
-          case "detect_ides": {
-            const results = await detectIDEs();
-            this.deps.detectedIdes.value = results;
-            return { success: true, detectedInfo: results };
-          }
-          // ─── Set User Name ───
-          case "set_user_name": {
-            const name = args?.userName;
-            if (!name || typeof name !== "string") throw new Error("userName required");
-            updateConfig({ userName: name });
-            return { success: true, userName: name };
-          }
-          case "mark_recent_seen": {
-            const kind = args?.kind;
-            const providerType = args?.providerType;
-            if (!kind || !providerType) {
-              return { success: false, error: "kind and providerType are required" };
-            }
-            const recentKey = args?.recentKey || buildRecentActivityKey({
-              kind,
-              providerType,
-              workspace: args?.workspace || null
-            });
-            const next = markRecentSessionSeen(
-              loadConfig(),
-              recentKey,
-              typeof args?.seenAt === "number" ? args.seenAt : Date.now()
-            );
-            saveConfig(next);
-            this.deps.onStatusChange?.();
-            return {
-              success: true,
-              recentKey,
-              seenAt: next.recentSessionReads?.[recentKey] || Date.now()
-            };
-          }
-          // ─── Daemon Self-Upgrade ───
-          case "daemon_upgrade": {
-            LOG.info("Upgrade", "Remote upgrade requested from dashboard");
-            try {
-              const { execSync: execSync7 } = await import("child_process");
-              const isStandalone = this.deps.packageName === "@adhdev/daemon-standalone" || process.argv[1]?.includes("daemon-standalone");
-              const pkgName = isStandalone ? "@adhdev/daemon-standalone" : "adhdev";
-              const latest = execSync7(`npm view ${pkgName} version`, { encoding: "utf-8", timeout: 1e4 }).trim();
-              LOG.info("Upgrade", `Latest ${pkgName}: v${latest}`);
-              execSync7(`npm install -g ${pkgName}@latest --force`, {
-                encoding: "utf-8",
-                timeout: 12e4,
-                stdio: ["pipe", "pipe", "pipe"]
-              });
-              LOG.info("Upgrade", `\u2705 Upgraded to v${latest}`);
-              setTimeout(() => {
-                LOG.info("Upgrade", "Restarting daemon with new version...");
-                try {
-                  const path18 = require("path");
-                  const fs16 = require("fs");
-                  const pidFile = path18.join(process.env.HOME || process.env.USERPROFILE || "", ".adhdev", "daemon.pid");
-                  if (fs16.existsSync(pidFile)) fs16.unlinkSync(pidFile);
-                } catch {
-                }
-                const { spawn: spawn4 } = require("child_process");
-                const child = spawn4(process.execPath, process.argv.slice(1), {
-                  detached: true,
-                  stdio: "ignore",
-                  env: { ...process.env }
-                });
-                child.unref();
-                process.exit(0);
-              }, 3e3);
-              return { success: true, upgraded: true, version: latest };
-            } catch (e) {
-              LOG.error("Upgrade", `Failed: ${e.message}`);
-              return { success: false, error: e.message };
-            }
-          }
-          // ─── Machine Settings ───
-          case "set_machine_nickname": {
-            const nickname = args?.nickname;
-            updateConfig({ machineNickname: nickname || null });
-            return { success: true };
-          }
-          default:
-            break;
-        }
-        return null;
-      }
-      /**
-       * IDE stop: CDP disconnect + InstanceManager cleanup + optionally kill OS process
-       */
-      async stopIde(ideType, killProcess = false) {
-        const cdpKeysToRemove = [];
-        for (const key of this.deps.cdpManagers.keys()) {
-          if (key === ideType || key.startsWith(`${ideType}_`)) {
-            cdpKeysToRemove.push(key);
-          }
-        }
-        for (const key of cdpKeysToRemove) {
-          const cdp = this.deps.cdpManagers.get(key);
-          if (cdp) {
-            try {
-              cdp.disconnect();
-            } catch {
-            }
-            this.deps.cdpManagers.delete(key);
-            this.deps.sessionRegistry.unregisterByManagerKey(key);
-            LOG.info("StopIDE", `CDP disconnected: ${key}`);
-          }
-        }
-        const keysToRemove = [];
-        for (const key of this.deps.instanceManager.listInstanceIds()) {
-          if (key === `ide:${ideType}` || typeof key === "string" && key.startsWith(`ide:${ideType}_`)) {
-            keysToRemove.push(key);
-          }
-        }
-        for (const instanceKey of keysToRemove) {
-          const ideInstance = this.deps.instanceManager.getInstance(instanceKey);
-          if (ideInstance) {
-            this.deps.instanceManager.removeInstance(instanceKey);
-            LOG.info("StopIDE", `Instance removed: ${instanceKey}`);
-          }
-        }
-        if (keysToRemove.length === 0) {
-          const instanceKey = `ide:${ideType}`;
-          const ideInstance = this.deps.instanceManager.getInstance(instanceKey);
-          if (ideInstance) {
-            this.deps.instanceManager.removeInstance(instanceKey);
-            LOG.info("StopIDE", `Instance removed: ${instanceKey}`);
-          }
-        }
-        if (killProcess) {
-          const running = isIdeRunning(ideType);
-          if (running) {
-            LOG.info("StopIDE", `Killing IDE process: ${ideType}`);
-            const killed = await killIdeProcess(ideType);
-            if (killed) {
-              LOG.info("StopIDE", `\u2705 Process killed: ${ideType}`);
-            } else {
-              LOG.warn("StopIDE", `\u26A0 Could not kill process: ${ideType} (may need manual intervention)`);
-            }
-          } else {
-            LOG.info("StopIDE", `Process not running: ${ideType}`);
-          }
-        }
-        this.deps.onStatusChange?.();
-        LOG.info("StopIDE", `IDE stopped: ${ideType} (processKill=${killProcess})`);
-      }
-    };
-  }
-});
-
 // ../../oss/packages/daemon-core/src/cli-adapters/terminal-backends/ghostty-vt-backend.ts
 function isModuleNotFoundError(error48, ref) {
   if (!(error48 instanceof Error)) return false;
@@ -9996,7 +9677,7 @@ function Ec(s15, t) {
 function Tc(s15) {
   return s15.keyCode === 16 || s15.keyCode === 17 || s15.keyCode === 18;
 }
-var zs, Rl, Ll, M, S, Gs, mi, $s, _i, er, tr, ir, we, De, rt, q, js, Hn, Fn, F, rr, ge, Zs, xt, nr, H, sr, Js, Be, wt, nt, ae, Dt, ce, Qs, or, Re, lr, Wn, Bl, Un, bi, ar, Rt, cr, ro, so, At, lo, ao, oo, ur, zn, Wl, dt, hr, dr, Ee, D, ye, fe, kt, G, Ct, zl, mr, Gl, fo, $l, $, Mt, $n, po, br, Vn, gi, qn, Yn, Vl, Pt, ql, Yl, _r, v, jn, gr, Si, Eu, Tu, Ot, Ei, Bt, Ti, Sr, Iu, yu, vr, Nt, yr, xr, Ii, Zl, vo, go, Jl, Ql, ea, ta, Tr, Ir, bo, ia, $e, Ve, xe, So, ra, Xn, wr, Te, Zn, Dr, na, xu, Fe, st, sa, oa, Eo, la, wu, Du, Ru, Lu, ot, aa, yi, Jn, To, Io, yo, Qn, Rr, es, ua, ha, da, fa, ft, wo, Lr, qe, xi, Do, ma, ts2, Ye, kr, ba, Ar, va, _e, Cr, Bh, be, Nh, Fh, Hh, Oo, Wh, Uh, No, Kh, zh, ss, os10, wa, mt, Mr, Di, pt, Gh, Y, Da, ls, Wt, He, Q, Pr, lt, Uo, Or, cs, Ri, Br, Nr, Fr, Ca, Ut, Kt, Wr, Ur, Ma, Ko, zo, us, zr, hs, ds, Kr, zt, Gt, Gr, We, at, Li, bt, b, Ai, fs8, $t, ue, he, de, J, ps, j, U, z, ve, $r, Vr, ct, Vt, Yr, ms, _s, Le, jr, jo, ki, Xr, Na, Yt, jt, Zr, bs, vs, Jr, gs, Qr, Xt, en, tn, Mi, Pi, Oi, Ss, Fa, Zo, Zt, Wa, Ua, Es, Bi, Ts, rn, Is, ys, Jt, nn, Qt, xs, on, Ds, Ya, ja, Xa, Za, Ja, ei, Hi, Wi, re, St, Ki, tl, il, Ui, Qa, ti, Rs, ln, ec, tc, ii, ic, zi, B, X, an, Ls, Ze, un, cn, ne, Je, cl, $i, hn, ks, Cs, ni, si, nc, dn, ul, hl, li, dl, Ps, fl, ai, Os, ac, se, fn, Ae, pn, Vi, uc, ci, qi, mn, pe, Yi, _n, ji, Xi, Fs, ke, hc, bn, dc, fc, mc, ut, _l, vl, gl, vn, Zi, _c, El, bc, gn, ui, Tl, Sn, gc, ee, En, Us, yl, Tn, Ks, Sc, In, xl, wl, Tt, hi, yn, xn, wn, Ji, Dn, Rn, Ln, Ic, Ue, Dl;
+var zs, Rl, Ll, M, S, Gs, mi, $s, _i, er, tr, ir, we, De, rt, q, js, Hn, Fn, F, rr, ge, Zs, xt, nr, H, sr, Js, Be, wt, nt, ae, Dt, ce, Qs, or, Re, lr, Wn, Bl, Un, bi, ar, Rt, cr, ro, so, At, lo, ao, oo, ur, zn, Wl, dt, hr, dr, Ee, D, ye, fe, kt, G, Ct, zl, mr, Gl, fo, $l, $, Mt, $n, po, br, Vn, gi, qn, Yn, Vl, Pt, ql, Yl, _r, v, jn, gr, Si, Eu, Tu, Ot, Ei, Bt, Ti, Sr, Iu, yu, vr, Nt, yr, xr, Ii, Zl, vo, go, Jl, Ql, ea, ta, Tr, Ir, bo, ia, $e, Ve, xe, So, ra, Xn, wr, Te, Zn, Dr, na, xu, Fe, st, sa, oa, Eo, la, wu, Du, Ru, Lu, ot, aa, yi, Jn, To, Io, yo, Qn, Rr, es, ua, ha, da, fa, ft, wo, Lr, qe, xi, Do, ma, ts2, Ye, kr, ba, Ar, va, _e, Cr, Bh, be, Nh, Fh, Hh, Oo, Wh, Uh, No, Kh, zh, ss, os10, wa, mt, Mr, Di, pt, Gh, Y, Da, ls, Wt, He, Q, Pr, lt, Uo, Or, cs, Ri, Br, Nr, Fr, Ca, Ut, Kt, Wr, Ur, Ma, Ko, zo, us, zr, hs, ds, Kr, zt, Gt, Gr, We, at, Li, bt, b, Ai, fs7, $t, ue, he, de, J, ps, j, U, z, ve, $r, Vr, ct, Vt, Yr, ms, _s, Le, jr, jo, ki, Xr, Na, Yt, jt, Zr, bs, vs, Jr, gs, Qr, Xt, en, tn, Mi, Pi, Oi, Ss, Fa, Zo, Zt, Wa, Ua, Es, Bi, Ts, rn, Is, ys, Jt, nn, Qt, xs, on, Ds, Ya, ja, Xa, Za, Ja, ei, Hi, Wi, re, St, Ki, tl, il, Ui, Qa, ti, Rs, ln, ec, tc, ii, ic, zi, B, X, an, Ls, Ze, un, cn, ne, Je, cl, $i, hn, ks, Cs, ni, si, nc, dn, ul, hl, li, dl, Ps, fl, ai, Os, ac, se, fn, Ae, pn, Vi, uc, ci, qi, mn, pe, Yi, _n, ji, Xi, Fs, ke, hc, bn, dc, fc, mc, ut, _l, vl, gl, vn, Zi, _c, El, bc, gn, ui, Tl, Sn, gc, ee, En, Us, yl, Tn, Ks, Sc, In, xl, wl, Tt, hi, yn, xn, wn, Ji, Dn, Rn, Ln, Ic, Ue, Dl;
 var init_xterm = __esm({
   "../../oss/node_modules/@xterm/xterm/lib/xterm.mjs"() {
     "use strict";
@@ -13271,7 +12952,7 @@ ${h.join(`
     ((E) => (E.NUL = "\0", E.SOH = "
", E.STX = "", E.ETX = "", E.EOT = "", E.ENQ = "", E.ACK = "", E.BEL = "\x07", E.BS = "\b", E.HT = "	", E.LF = `
 `, E.VT = "\v", E.FF = "\f", E.CR = "\r", E.SO = "", E.SI = "", E.DLE = "", E.DC1 = "", E.DC2 = "", E.DC3 = "", E.DC4 = "", E.NAK = "", E.SYN = "", E.ETB = "", E.CAN = "", E.EM = "", E.SUB = "", E.ESC = "\x1B", E.FS = "", E.GS = "", E.RS = "", E.US = "", E.SP = " ", E.DEL = "\x7F"))(b ||= {});
     ((g) => (g.PAD = "\x80", g.HOP = "\x81", g.BPH = "\x82", g.NBH = "\x83", g.IND = "\x84", g.NEL = "\x85", g.SSA = "\x86", g.ESA = "\x87", g.HTS = "\x88", g.HTJ = "\x89", g.VTS = "\x8A", g.PLD = "\x8B", g.PLU = "\x8C", g.RI = "\x8D", g.SS2 = "\x8E", g.SS3 = "\x8F", g.DCS = "\x90", g.PU1 = "\x91", g.PU2 = "\x92", g.STS = "\x93", g.CCH = "\x94", g.MW = "\x95", g.SPA = "\x96", g.EPA = "\x97", g.SOS = "\x98", g.SGCI = "\x99", g.SCI = "\x9A", g.CSI = "\x9B", g.ST = "\x9C", g.OSC = "\x9D", g.PM = "\x9E", g.APC = "\x9F"))(Ai ||= {});
-    ((t) => t.ST = `${b.ESC}\\`)(fs8 ||= {});
+    ((t) => t.ST = `${b.ESC}\\`)(fs7 ||= {});
     $t = class {
       constructor(t, e, i, r, n, o) {
         this._textarea = t;
@@ -17700,7 +17381,7 @@ ${h.join(`
           switch (i.type) {
             case 0:
               let o = U.toColorRGB(r === "ansi" ? this._themeService.colors.ansi[i.index] : this._themeService.colors[r]);
-              this.coreService.triggerDataEvent(`${b.ESC}]${n};${ml(o)}${fs8.ST}`);
+              this.coreService.triggerDataEvent(`${b.ESC}]${n};${ml(o)}${fs7.ST}`);
               break;
             case 1:
               if (r === "ansi") this._themeService.modifyColors((l) => l.ansi[i.index] = j.toColor(...i.color));
@@ -18541,94 +18222,45 @@ function getSessionMessageUpdatedAt(session) {
   if (!lastMessage) return 0;
   return parseMessageTime(lastMessage.timestamp) || parseMessageTime(lastMessage.receivedAt) || parseMessageTime(lastMessage.createdAt) || 0;
 }
+function getSessionCompletionMarker(session) {
+  const lastMessage = session.activeChat?.messages?.at?.(-1);
+  if (!lastMessage) return "";
+  const role = typeof lastMessage.role === "string" ? lastMessage.role : "";
+  if (role === "user" || role === "human") return "";
+  if (typeof lastMessage._turnKey === "string" && lastMessage._turnKey) return `turn:${lastMessage._turnKey}`;
+  if (typeof lastMessage.id === "string" && lastMessage.id) return `id:${lastMessage.id}`;
+  if (typeof lastMessage.index === "number" && Number.isFinite(lastMessage.index)) return `idx:${lastMessage.index}`;
+  const timestamp = parseMessageTime(lastMessage.timestamp) || parseMessageTime(lastMessage.receivedAt) || parseMessageTime(lastMessage.createdAt);
+  return timestamp > 0 ? `ts:${timestamp}` : "";
+}
 function getSessionLastUsedAt(session) {
   return getSessionMessageUpdatedAt(session) || session.lastUpdated || Date.now();
 }
-function getSessionKind(session) {
-  return session.transport === "cdp-page" || session.transport === "cdp-webview" ? "ide" : session.transport === "acp" ? "acp" : "cli";
-}
 function getLastMessageRole(session) {
   const role = session.activeChat?.messages?.at?.(-1)?.role;
   return typeof role === "string" ? role : "";
 }
-function getUnreadState(hasContentChange, status, lastUsedAt, lastSeenAt, lastRole) {
+function getUnreadState(hasContentChange, status, lastUsedAt, lastSeenAt, lastRole, completionMarker, seenCompletionMarker) {
   if (status === "waiting_approval") {
     return { unread: false, inboxBucket: "needs_attention" };
   }
   if (status === "generating" || status === "starting") {
     return { unread: false, inboxBucket: "working" };
   }
-  const unread = hasContentChange && lastUsedAt > lastSeenAt && lastRole !== "user" && lastRole !== "human";
+  const unread = completionMarker ? completionMarker !== seenCompletionMarker : hasContentChange && lastUsedAt > lastSeenAt && lastRole !== "user" && lastRole !== "human";
   return { unread, inboxBucket: unread ? "task_complete" : "idle" };
 }
-function buildRecentSessions(sessions, recentActivity, readState) {
-  const visibleKeys = /* @__PURE__ */ new Set();
-  const hiddenKeys = /* @__PURE__ */ new Set();
-  const live = sessions.filter((session) => !session.surfaceHidden && session.status !== "stopped").map((session) => {
-    const kind = getSessionKind(session);
-    const recentKey = buildRecentActivityKey({
-      kind,
-      providerType: session.providerType,
-      workspace: session.workspace
-    });
-    const lastSeenAt = readState[recentKey] || 0;
-    const lastUsedAt = getSessionLastUsedAt(session);
-    const { unread, inboxBucket } = getUnreadState(
-      getSessionMessageUpdatedAt(session) > 0,
-      session.status,
-      lastUsedAt,
-      lastSeenAt,
-      getLastMessageRole(session)
-    );
-    return {
-      id: session.id,
-      recentKey,
-      sessionId: session.id,
-      providerType: session.providerType,
-      providerName: session.providerName,
-      kind,
-      title: session.activeChat?.title || session.title || session.providerName,
-      workspace: session.workspace,
-      currentModel: session.currentModel,
-      status: session.status,
-      lastUsedAt,
-      unread,
-      lastSeenAt,
-      inboxBucket,
-      surfaceHidden: false
-    };
-  });
-  for (const item of live) {
-    visibleKeys.add(`${item.kind}:${item.providerType}:${item.workspace || ""}`);
-  }
-  for (const session of sessions) {
-    if (!session.surfaceHidden) continue;
-    hiddenKeys.add(`${getSessionKind(session)}:${session.providerType}:${session.workspace || ""}`);
-  }
-  const persisted = recentActivity.filter((item) => {
-    const key = `${item.kind}:${item.providerType}:${item.workspace || ""}`;
-    return !visibleKeys.has(key) && !hiddenKeys.has(key);
-  }).map((item) => {
-    const lastSeenAt = readState[item.id] || 0;
-    const unread = item.lastUsedAt > lastSeenAt;
-    return {
-      id: item.id,
-      recentKey: item.id,
-      sessionId: item.sessionId || null,
-      providerType: item.providerType,
-      providerName: item.providerName,
-      kind: item.kind,
-      title: item.title || item.providerName,
-      workspace: item.workspace,
-      currentModel: item.currentModel,
-      lastUsedAt: item.lastUsedAt,
-      unread,
-      lastSeenAt,
-      inboxBucket: unread ? "task_complete" : "idle",
-      surfaceHidden: false
-    };
-  });
-  return [...live, ...persisted].sort((a, b2) => b2.lastUsedAt - a.lastUsedAt).slice(0, 12);
+function buildRecentLaunches(recentActivity) {
+  return recentActivity.map((item) => ({
+    id: item.id,
+    providerType: item.providerType,
+    providerName: item.providerName,
+    kind: item.kind,
+    title: item.title || item.providerName,
+    workspace: item.workspace,
+    currentModel: item.currentModel,
+    lastLaunchedAt: item.lastUsedAt
+  })).sort((a, b2) => b2.lastLaunchedAt - a.lastLaunchedAt).slice(0, 12);
 }
 function buildStatusSnapshot(options) {
   const cfg = loadConfig();
@@ -18639,27 +18271,29 @@ function buildStatusSnapshot(options) {
     options.allStates,
     options.cdpManagers
   );
-  const readState = cfg.recentSessionReads || {};
   for (const session of sessions) {
-    const kind = getSessionKind(session);
-    const recentKey = buildRecentActivityKey({
-      kind,
-      providerType: session.providerType,
-      workspace: session.workspace
-    });
-    const lastSeenAt = getRecentSessionSeenAt(cfg, recentKey);
+    const lastSeenAt = getSessionSeenAt(cfg, session.id);
+    const seenCompletionMarker = getSessionSeenMarker(cfg, session.id);
     const lastUsedAt = getSessionLastUsedAt(session);
+    const completionMarker = getSessionCompletionMarker(session);
     const { unread, inboxBucket } = session.surfaceHidden ? { unread: false, inboxBucket: "idle" } : getUnreadState(
       getSessionMessageUpdatedAt(session) > 0,
       session.status,
       lastUsedAt,
       lastSeenAt,
-      getLastMessageRole(session)
+      getLastMessageRole(session),
+      completionMarker,
+      seenCompletionMarker
     );
-    session.recentKey = recentKey;
     session.lastSeenAt = lastSeenAt;
     session.unread = unread;
     session.inboxBucket = inboxBucket;
+    if (READ_DEBUG_ENABLED && (session.unread || session.inboxBucket !== "idle" || session.providerType.includes("codex"))) {
+      LOG.info(
+        "RecentRead",
+        `snapshot session id=${session.id} provider=${session.providerType} status=${String(session.status || "")} bucket=${inboxBucket} unread=${String(unread)} lastSeenAt=${lastSeenAt} completionMarker=${completionMarker || "-"} seenMarker=${seenCompletionMarker || "-"} lastUpdated=${String(session.lastUpdated || 0)} lastUsedAt=${lastUsedAt} lastRole=${getLastMessageRole(session)} msgUpdatedAt=${getSessionMessageUpdatedAt(session)}`
+      );
+    }
   }
   const terminalBackend = getTerminalBackendRuntimeStatus();
   return {
@@ -18686,12 +18320,12 @@ function buildStatusSnapshot(options) {
     workspaces: wsState.workspaces,
     defaultWorkspaceId: wsState.defaultWorkspaceId,
     defaultWorkspacePath: wsState.defaultWorkspacePath,
-    recentSessions: buildRecentSessions(sessions, recentActivity, readState),
+    recentLaunches: buildRecentLaunches(recentActivity),
     terminalBackend,
     availableProviders: buildAvailableProviders(options.providerLoader)
   };
 }
-var os11;
+var os11, READ_DEBUG_ENABLED;
 var init_snapshot = __esm({
   "../../oss/packages/daemon-core/src/status/snapshot.ts"() {
     "use strict";
@@ -18701,7 +18335,350 @@ var init_snapshot = __esm({
     init_workspaces();
     init_host_memory();
     init_terminal_screen();
+    init_logger();
+    init_builders();
+    READ_DEBUG_ENABLED = process.argv.includes("--dev") || process.env.ADHDEV_READ_DEBUG === "1";
+  }
+});
+
+// ../../oss/packages/daemon-core/src/commands/router.ts
+var fs8, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter;
+var init_router = __esm({
+  "../../oss/packages/daemon-core/src/commands/router.ts"() {
+    "use strict";
+    init_manager();
+    init_setup();
+    init_launch();
+    init_config();
+    init_workspaces();
+    init_recent_activity();
+    init_ide_detector();
+    init_logger();
+    init_command_log();
+    init_logger();
     init_builders();
+    init_snapshot();
+    fs8 = __toESM(require("fs"));
+    CHAT_COMMANDS = [
+      "send_chat",
+      "new_chat",
+      "switch_chat",
+      "set_mode",
+      "change_model"
+    ];
+    READ_DEBUG_ENABLED2 = process.argv.includes("--dev") || process.env.ADHDEV_READ_DEBUG === "1";
+    DaemonCommandRouter = class {
+      deps;
+      constructor(deps) {
+        this.deps = deps;
+      }
+      /**
+       * Unified command routing.
+       * Returns result for all commands:
+       *   1. Daemon-level commands (launch_ide, stop_ide, etc.)
+       *   2. CLI commands (launch_cli, stop_cli, agent_command)
+       *   3. DaemonCommandHandler delegation (CDP/agent-stream/file commands)
+       *
+       * @param cmd Command name
+       * @param args Command arguments
+       * @param source Log source ('ws' | 'p2p' | 'standalone' | etc.)
+       */
+      async execute(cmd, args, source = "unknown") {
+        const cmdStart = Date.now();
+        try {
+          const daemonResult = await this.executeDaemonCommand(cmd, args);
+          if (daemonResult) {
+            logCommand({ ts: (/* @__PURE__ */ new Date()).toISOString(), cmd, source, args, success: daemonResult.success, durationMs: Date.now() - cmdStart });
+            return daemonResult;
+          }
+          const handlerResult = await this.deps.commandHandler.handle(cmd, args);
+          logCommand({ ts: (/* @__PURE__ */ new Date()).toISOString(), cmd, source, args, success: handlerResult.success, durationMs: Date.now() - cmdStart });
+          if (CHAT_COMMANDS.includes(cmd) && this.deps.onPostChatCommand) {
+            this.deps.onPostChatCommand();
+          }
+          return handlerResult;
+        } catch (e) {
+          logCommand({ ts: (/* @__PURE__ */ new Date()).toISOString(), cmd, source, args, success: false, error: e.message, durationMs: Date.now() - cmdStart });
+          throw e;
+        }
+      }
+      // ─── Daemon-level command core ───────────────────
+      /**
+       * Daemon-level command execution (IDE start/stop/restart, CLI, detect, logs).
+       * Returns null if not handled at this level → caller delegates to CommandHandler.
+       */
+      async executeDaemonCommand(cmd, args) {
+        switch (cmd) {
+          // ─── CLI / ACP commands ───
+          case "launch_cli":
+          case "stop_cli":
+          case "agent_command": {
+            return this.deps.cliManager.handleCliCommand(cmd, args);
+          }
+          // ─── Logs ───
+          case "get_logs": {
+            const count = parseInt(args?.count) || parseInt(args?.lines) || 100;
+            const minLevel = args?.minLevel || "info";
+            const sinceTs = args?.since || 0;
+            try {
+              let logs = getRecentLogs(count, minLevel);
+              if (sinceTs > 0) {
+                logs = logs.filter((l) => l.ts > sinceTs);
+              }
+              if (logs.length > 0) {
+                return { success: true, logs, totalBuffered: logs.length };
+              }
+              if (fs8.existsSync(LOG_PATH)) {
+                const content = fs8.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 };
+              }
+              return { success: true, logs: [], totalBuffered: 0 };
+            } catch (e) {
+              return { success: false, error: e.message };
+            }
+          }
+          // ─── restart_session: IDE / CLI / ACP unified ───
+          case "restart_session": {
+            const targetType = args?.cliType || args?.agentType || args?.ideType;
+            if (!targetType) throw new Error("cliType or ideType required");
+            const isIde = this.deps.cdpManagers.has(targetType) || this.deps.providerLoader.getMeta(targetType)?.category === "ide";
+            if (isIde) {
+              await this.stopIde(targetType, true);
+              const launchResult = await this.executeDaemonCommand("launch_ide", { ideType: targetType, enableCdp: true, workspace: args?.workspace });
+              return { success: true, restarted: true, ideType: targetType, launch: launchResult };
+            }
+            return this.deps.cliManager.handleCliCommand(cmd, args);
+          }
+          // ─── IDE stop ───
+          case "stop_ide": {
+            const ideType = args?.ideType;
+            if (!ideType) throw new Error("ideType required");
+            const killProcess = args?.killProcess !== false;
+            await this.stopIde(ideType, killProcess);
+            return { success: true, ideType, stopped: true, processKilled: killProcess };
+          }
+          // ─── IDE restart ───
+          case "restart_ide": {
+            const ideType = args?.ideType;
+            if (!ideType) throw new Error("ideType required");
+            await this.stopIde(ideType, true);
+            const launchResult = await this.executeDaemonCommand("launch_ide", { ideType, enableCdp: true, workspace: args?.workspace });
+            return { success: true, ideType, restarted: true, launch: launchResult };
+          }
+          // ─── IDE launch + CDP connect ───
+          case "launch_ide": {
+            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)) {
+              const logFn = this.deps.getCdpLogFn ? this.deps.getCdpLogFn(result.ideId) : LOG.forComponent(`CDP:${result.ideId}`).asLogFn();
+              const provider = this.deps.providerLoader.getMeta(result.ideId);
+              const manager = new DaemonCdpManager(result.port, logFn, void 0, provider?.targetFilter);
+              const connected = await manager.connect();
+              if (connected) {
+                registerExtensionProviders(this.deps.providerLoader, manager, result.ideId);
+                this.deps.cdpManagers.set(result.ideId, manager);
+                LOG.info("CDP", `Connected: ${result.ideId} (port ${result.port})`);
+                LOG.info("CDP", `${this.deps.cdpManagers.size} IDE(s) connected`);
+                this.deps.onCdpManagerCreated?.(result.ideId, manager);
+              }
+            }
+            this.deps.onIdeConnected?.();
+            if (result.success && resolvedWorkspace) {
+              try {
+                const next = appendRecentActivity(loadConfig(), {
+                  kind: "ide",
+                  providerType: result.ideId || ideKey,
+                  providerName: result.ideId || ideKey,
+                  workspace: resolvedWorkspace,
+                  title: result.ideId || ideKey
+                });
+                saveConfig(next);
+              } catch {
+              }
+            } else if (result.success && (result.ideId || ideKey)) {
+              try {
+                saveConfig(appendRecentActivity(loadConfig(), {
+                  kind: "ide",
+                  providerType: result.ideId || ideKey,
+                  providerName: result.ideId || ideKey,
+                  title: result.ideId || ideKey
+                }));
+              } catch {
+              }
+            }
+            return { success: result.success, ...result };
+          }
+          // ─── Detect IDEs ───
+          case "detect_ides": {
+            const results = await detectIDEs();
+            this.deps.detectedIdes.value = results;
+            return { success: true, detectedInfo: results };
+          }
+          // ─── Set User Name ───
+          case "set_user_name": {
+            const name = args?.userName;
+            if (!name || typeof name !== "string") throw new Error("userName required");
+            updateConfig({ userName: name });
+            return { success: true, userName: name };
+          }
+          case "mark_session_seen": {
+            const sessionId = args?.sessionId;
+            if (!sessionId || typeof sessionId !== "string") {
+              return { success: false, error: "sessionId is required" };
+            }
+            const currentConfig = loadConfig();
+            const prevSeenAt = currentConfig.sessionReads?.[sessionId] || 0;
+            const sessionEntries = buildSessionEntries(
+              this.deps.instanceManager.collectAllStates(),
+              this.deps.cdpManagers
+            );
+            const targetSession = sessionEntries.find((entry) => entry.id === sessionId);
+            const completionMarker = targetSession ? getSessionCompletionMarker(targetSession) : "";
+            const next = markSessionSeen(
+              currentConfig,
+              sessionId,
+              typeof args?.seenAt === "number" ? args.seenAt : Date.now(),
+              completionMarker
+            );
+            if (READ_DEBUG_ENABLED2) {
+              LOG.info("RecentRead", `mark_session_seen sessionId=${sessionId} seenAt=${String(args?.seenAt || "")} prevSeenAt=${String(prevSeenAt)} nextSeenAt=${String(next.sessionReads?.[sessionId] || 0)} marker=${completionMarker || "-"}`);
+            }
+            saveConfig(next);
+            this.deps.onStatusChange?.();
+            return {
+              success: true,
+              sessionId,
+              seenAt: next.sessionReads?.[sessionId] || Date.now(),
+              completionMarker
+            };
+          }
+          // ─── Daemon Self-Upgrade ───
+          case "daemon_upgrade": {
+            LOG.info("Upgrade", "Remote upgrade requested from dashboard");
+            try {
+              const { execSync: execSync7 } = await import("child_process");
+              const isStandalone = this.deps.packageName === "@adhdev/daemon-standalone" || process.argv[1]?.includes("daemon-standalone");
+              const pkgName = isStandalone ? "@adhdev/daemon-standalone" : "adhdev";
+              const latest = execSync7(`npm view ${pkgName} version`, { encoding: "utf-8", timeout: 1e4 }).trim();
+              LOG.info("Upgrade", `Latest ${pkgName}: v${latest}`);
+              execSync7(`npm install -g ${pkgName}@latest --force`, {
+                encoding: "utf-8",
+                timeout: 12e4,
+                stdio: ["pipe", "pipe", "pipe"]
+              });
+              LOG.info("Upgrade", `\u2705 Upgraded to v${latest}`);
+              setTimeout(() => {
+                LOG.info("Upgrade", "Restarting daemon with new version...");
+                try {
+                  const path18 = require("path");
+                  const fs16 = require("fs");
+                  const pidFile = path18.join(process.env.HOME || process.env.USERPROFILE || "", ".adhdev", "daemon.pid");
+                  if (fs16.existsSync(pidFile)) fs16.unlinkSync(pidFile);
+                } catch {
+                }
+                const { spawn: spawn4 } = require("child_process");
+                const child = spawn4(process.execPath, process.argv.slice(1), {
+                  detached: true,
+                  stdio: "ignore",
+                  env: { ...process.env }
+                });
+                child.unref();
+                process.exit(0);
+              }, 3e3);
+              return { success: true, upgraded: true, version: latest };
+            } catch (e) {
+              LOG.error("Upgrade", `Failed: ${e.message}`);
+              return { success: false, error: e.message };
+            }
+          }
+          // ─── Machine Settings ───
+          case "set_machine_nickname": {
+            const nickname = args?.nickname;
+            updateConfig({ machineNickname: nickname || null });
+            return { success: true };
+          }
+          default:
+            break;
+        }
+        return null;
+      }
+      /**
+       * IDE stop: CDP disconnect + InstanceManager cleanup + optionally kill OS process
+       */
+      async stopIde(ideType, killProcess = false) {
+        const cdpKeysToRemove = [];
+        for (const key of this.deps.cdpManagers.keys()) {
+          if (key === ideType || key.startsWith(`${ideType}_`)) {
+            cdpKeysToRemove.push(key);
+          }
+        }
+        for (const key of cdpKeysToRemove) {
+          const cdp = this.deps.cdpManagers.get(key);
+          if (cdp) {
+            try {
+              cdp.disconnect();
+            } catch {
+            }
+            this.deps.cdpManagers.delete(key);
+            this.deps.sessionRegistry.unregisterByManagerKey(key);
+            LOG.info("StopIDE", `CDP disconnected: ${key}`);
+          }
+        }
+        const keysToRemove = [];
+        for (const key of this.deps.instanceManager.listInstanceIds()) {
+          if (key === `ide:${ideType}` || typeof key === "string" && key.startsWith(`ide:${ideType}_`)) {
+            keysToRemove.push(key);
+          }
+        }
+        for (const instanceKey of keysToRemove) {
+          const ideInstance = this.deps.instanceManager.getInstance(instanceKey);
+          if (ideInstance) {
+            this.deps.instanceManager.removeInstance(instanceKey);
+            LOG.info("StopIDE", `Instance removed: ${instanceKey}`);
+          }
+        }
+        if (keysToRemove.length === 0) {
+          const instanceKey = `ide:${ideType}`;
+          const ideInstance = this.deps.instanceManager.getInstance(instanceKey);
+          if (ideInstance) {
+            this.deps.instanceManager.removeInstance(instanceKey);
+            LOG.info("StopIDE", `Instance removed: ${instanceKey}`);
+          }
+        }
+        if (killProcess) {
+          const running = isIdeRunning(ideType);
+          if (running) {
+            LOG.info("StopIDE", `Killing IDE process: ${ideType}`);
+            const killed = await killIdeProcess(ideType);
+            if (killed) {
+              LOG.info("StopIDE", `\u2705 Process killed: ${ideType}`);
+            } else {
+              LOG.warn("StopIDE", `\u26A0 Could not kill process: ${ideType} (may need manual intervention)`);
+            }
+          } else {
+            LOG.info("StopIDE", `Process not running: ${ideType}`);
+          }
+        }
+        this.deps.onStatusChange?.();
+        LOG.info("StopIDE", `IDE stopped: ${ideType} (processKill=${killProcess})`);
+      }
+    };
   }
 });
 
@@ -18860,7 +18837,7 @@ var init_reporter = __esm({
             currentModel: session.currentModel,
             currentPlan: session.currentPlan,
             currentAutoApprove: session.currentAutoApprove,
-            recentKey: session.recentKey,
+            lastUpdated: session.lastUpdated,
             unread: session.unread,
             lastSeenAt: session.lastSeenAt,
             inboxBucket: session.inboxBucket,
@@ -20122,12 +20099,14 @@ var init_cli_provider_instance = __esm({
     init_chat_history();
     init_logger();
     CliProviderInstance = class {
-      constructor(provider, workingDir, cliArgs = [], instanceId, transportFactory) {
+      constructor(provider, workingDir, cliArgs = [], instanceId, transportFactory, launchModeId) {
         this.provider = provider;
         this.workingDir = workingDir;
         this.cliArgs = cliArgs;
         this.type = provider.type;
         this.instanceId = instanceId || crypto3.randomUUID();
+        this.launchMode = launchModeId && provider.launchModes?.find((m) => m.id === launchModeId) || null;
+        this.resolvedOutputFormat = this.resolveOutputFormat();
         this.adapter = new ProviderCliAdapter(provider, workingDir, cliArgs, transportFactory);
         this.monitor = new StatusMonitor();
         this.historyWriter = new ChatHistoryWriter();
@@ -20146,6 +20125,26 @@ var init_cli_provider_instance = __esm({
       lastApprovalEventAt = 0;
       historyWriter;
       instanceId;
+      launchMode;
+      resolvedOutputFormat;
+      /**
+       * Determine output rendering format from:
+       * 1. launchMode.outputFormat (explicit override)
+       * 2. launchOptions[].outputFormatMap — check actual args for matching values
+       * 3. Default: 'terminal'
+       */
+      resolveOutputFormat() {
+        if (this.launchMode?.outputFormat) return this.launchMode.outputFormat;
+        if (this.provider.launchOptions?.length) {
+          for (const opt of this.provider.launchOptions) {
+            if (!opt.outputFormatMap) continue;
+            for (const [val, fmt] of Object.entries(opt.outputFormatMap)) {
+              if (this.cliArgs.includes(val)) return fmt;
+            }
+          }
+        }
+        return "terminal";
+      }
       // ─── Lifecycle ─────────────────────────────────
       async init(context) {
         this.context = context;
@@ -20185,7 +20184,8 @@ var init_cli_provider_instance = __esm({
           name: this.provider.name,
           category: "cli",
           status: adapterStatus.status,
-          mode: "terminal",
+          mode: this.resolvedOutputFormat === "stream-json" ? "chat" : "terminal",
+          launchMode: this.launchMode?.id,
           activeChat: {
             id: `${this.type}_${this.workingDir}`,
             title: `${this.provider.name} \xB7 ${dirName}`,
@@ -37656,12 +37656,12 @@ var init_cli_manager = __esm({
           }
         }, 3e3);
       }
-      async registerCliInstance(key, normalizedType, cliType, resolvedDir, cliArgs, provider, settings, attachExisting = false) {
+      async registerCliInstance(key, normalizedType, cliType, resolvedDir, cliArgs, provider, settings, attachExisting = false, launchModeId) {
         const instanceManager = this.deps.getInstanceManager();
         const sessionRegistry = this.deps.getSessionRegistry?.() || null;
         if (!instanceManager) throw new Error("InstanceManager not available");
         const transportFactory = this.getTransportFactory(key, normalizedType, resolvedDir, cliArgs, attachExisting);
-        const cliInstance = new CliProviderInstance(provider, resolvedDir, cliArgs, key, transportFactory);
+        const cliInstance = new CliProviderInstance(provider, resolvedDir, cliArgs, key, transportFactory, launchModeId);
         try {
           await instanceManager.addInstance(key, cliInstance, {
             serverConn: this.deps.getServerConn(),
@@ -37687,7 +37687,7 @@ var init_cli_manager = __esm({
         this.startCliExitMonitor(key, cliType);
       }
       // ─── Session start/management ──────────────────────────────
-      async startSession(cliType, workingDir, cliArgs, initialModel) {
+      async startSession(cliType, workingDir, cliArgs, initialModel, launchMode, launchOptionValues) {
         const trimmed = (workingDir || "").trim();
         if (!trimmed) throw new Error("working directory required");
         const resolvedDir = trimmed.startsWith("~") ? trimmed.replace(/^~/, os14.homedir()) : path10.resolve(trimmed);
@@ -37779,6 +37779,29 @@ ${installInfo}`
         if (provider) {
           console.log(colorize("cyan", `  \u{1F4E6} Using provider: ${provider.name} (${provider.type})`));
         }
+        let resolvedCliArgs = cliArgs;
+        let resolvedLaunchMode = launchMode;
+        const activeMode = provider?.launchModes?.length ? launchMode ? provider.launchModes.find((m) => m.id === launchMode) : provider.launchModes.find((m) => m.default) : void 0;
+        if (activeMode) {
+          resolvedLaunchMode = activeMode.id;
+        }
+        if (provider?.launchArgBuilder) {
+          const defaults = {};
+          for (const opt of provider.launchOptions || []) {
+            if (opt.default !== void 0) defaults[opt.id] = opt.default;
+          }
+          const modeOptions = activeMode?.options || {};
+          const userOptions = launchOptionValues || {};
+          const merged = { ...defaults, ...modeOptions, ...userOptions };
+          const extraArgs = provider.launchArgBuilder(merged);
+          if (extraArgs.length) {
+            resolvedCliArgs = [...cliArgs || [], ...extraArgs];
+            console.log(colorize("cyan", `  \u{1F680} Launch options applied: ${extraArgs.join(" ")}`));
+          }
+        } else if (activeMode?.extraArgs?.length) {
+          resolvedCliArgs = [...cliArgs || [], ...activeMode.extraArgs];
+          console.log(colorize("cyan", `  \u{1F680} Launch mode '${activeMode.name}': appending args ${activeMode.extraArgs.join(" ")}`));
+        }
         const instanceManager = this.deps.getInstanceManager();
         if (provider && instanceManager) {
           const resolvedProvider = this.providerLoader.resolve(cliType, { version: cliInfo.version }) || provider;
@@ -37787,14 +37810,15 @@ ${installInfo}`
             normalizedType,
             cliType,
             resolvedDir,
-            cliArgs,
+            resolvedCliArgs,
             resolvedProvider,
             {},
-            false
+            false,
+            resolvedLaunchMode
           );
           console.log(colorize("green", `  \u2713 CLI started: ${cliInfo.displayName} v${cliInfo.version || "unknown"} in ${resolvedDir}`));
         } else {
-          const adapter = this.createAdapter(cliType, resolvedDir, cliArgs, key, false);
+          const adapter = this.createAdapter(cliType, resolvedDir, resolvedCliArgs, key, false);
           try {
             await adapter.spawn();
           } catch (spawnErr) {
@@ -37902,7 +37926,8 @@ ${installInfo}`
               record2.cliArgs,
               resolvedProvider,
               {},
-              true
+              true,
+              record2.launchMode
             );
             restored += 1;
             LOG.info("CLI", `\u267B Restored hosted runtime: ${record2.runtimeKey || record2.runtimeId} (${record2.displayName || record2.workspace})`);
@@ -37972,7 +37997,7 @@ ${installInfo}`
             const dir = resolved.path;
             const launchSource = resolved.source;
             if (!cliType) throw new Error("cliType required");
-            await this.startSession(cliType, dir, args?.cliArgs, args?.initialModel);
+            await this.startSession(cliType, dir, args?.cliArgs, args?.initialModel, args?.launchMode, args?.launchOptionValues);
             let newKey = null;
             for (const [k, adapter] of this.adapters) {
               if (adapter.cliType === cliType && adapter.workingDir === dir) {
@@ -45685,7 +45710,7 @@ var init_adhdev_daemon = __esm({
     fs15 = __toESM(require("fs"));
     path17 = __toESM(require("path"));
     import_chalk2 = __toESM(require("chalk"));
-    pkgVersion = "0.7.39";
+    pkgVersion = "0.7.41";
     if (pkgVersion === "unknown") {
       try {
         const possiblePaths = [