@adhdev/daemon-core 0.7.39 → 0.7.41

package/dist/index.mjs

@@ -170,7 +170,8 @@ var init_config = __esm({
       workspaces: [],
       defaultWorkspaceId: null,
       recentActivity: [],
-      recentSessionReads: {},
+      sessionReads: {},
+      sessionReadMarkers: {},
       machineNickname: null,
       machineId: void 0,
       machineSecret: null,
@@ -2044,18 +2045,27 @@ function appendRecentActivity(config, entry) {
 function getRecentActivity(config, limit = 20) {
   return [...config.recentActivity || []].sort((a, b) => b.lastUsedAt - a.lastUsedAt).slice(0, limit);
 }
-function getRecentSessionSeenAt(config, recentKey) {
-  return config.recentSessionReads?.[recentKey] || 0;
+function getSessionSeenAt(config, sessionId) {
+  return config.sessionReads?.[sessionId] || 0;
 }
-function markRecentSessionSeen(config, recentKey, seenAt = Date.now()) {
-  const prev = config.recentSessionReads || {};
-  const nextSeenAt = Math.max(prev[recentKey] || 0, seenAt);
+function getSessionSeenMarker(config, sessionId) {
+  return config.sessionReadMarkers?.[sessionId] || "";
+}
+function markSessionSeen(config, sessionId, seenAt = Date.now(), completionMarker) {
+  const prev = config.sessionReads || {};
+  const nextSeenAt = Math.max(prev[sessionId] || 0, seenAt);
+  const prevMarkers = config.sessionReadMarkers || {};
+  const nextMarker = typeof completionMarker === "string" ? completionMarker : "";
   return {
     ...config,
-    recentSessionReads: {
+    sessionReads: {
       ...prev,
-      [recentKey]: nextSeenAt
-    }
+      [sessionId]: nextSeenAt
+    },
+    sessionReadMarkers: nextMarker ? {
+      ...prevMarkers,
+      [sessionId]: nextMarker
+    } : prevMarkers
   };
 }
 
@@ -4979,6 +4989,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,
@@ -8385,6 +8397,149 @@ cleanOldFiles();
 
 // src/commands/router.ts
 init_logger();
+
+// src/status/snapshot.ts
+init_config();
+import * as os10 from "os";
+init_terminal_screen();
+init_logger();
+var READ_DEBUG_ENABLED = process.argv.includes("--dev") || process.env.ADHDEV_READ_DEBUG === "1";
+function buildDetectedIdeInfos(detectedIdes, cdpManagers) {
+  return detectedIdes.filter((ide) => ide.installed !== false).map((ide) => ({
+    id: ide.id,
+    type: ide.id,
+    name: ide.displayName || ide.name || ide.id,
+    running: isCdpConnected(cdpManagers, ide.id),
+    ...ide.path ? { path: ide.path } : {}
+  }));
+}
+function buildAvailableProviders(providerLoader) {
+  return providerLoader.getAll().map((provider) => ({
+    type: provider.type,
+    name: provider.displayName || provider.type,
+    displayName: provider.displayName || provider.type,
+    icon: provider.icon || "\u{1F4BB}",
+    category: provider.category
+  }));
+}
+function parseMessageTime(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return 0;
+}
+function getSessionMessageUpdatedAt(session) {
+  const lastMessage = session.activeChat?.messages?.at?.(-1);
+  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 getLastMessageRole(session) {
+  const role = session.activeChat?.messages?.at?.(-1)?.role;
+  return typeof role === "string" ? role : "";
+}
+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 = completionMarker ? completionMarker !== seenCompletionMarker : hasContentChange && lastUsedAt > lastSeenAt && lastRole !== "user" && lastRole !== "human";
+  return { unread, inboxBucket: unread ? "task_complete" : "idle" };
+}
+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, b) => b.lastLaunchedAt - a.lastLaunchedAt).slice(0, 12);
+}
+function buildStatusSnapshot(options) {
+  const cfg = loadConfig();
+  const wsState = getWorkspaceState(cfg);
+  const memSnap = getHostMemorySnapshot();
+  const recentActivity = getRecentActivity(cfg, 20);
+  const sessions = buildSessionEntries(
+    options.allStates,
+    options.cdpManagers
+  );
+  for (const session of sessions) {
+    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),
+      completionMarker,
+      seenCompletionMarker
+    );
+    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 {
+    instanceId: options.instanceId,
+    version: options.version,
+    daemonMode: options.daemonMode,
+    machine: {
+      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(),
+      release: os10.release()
+    },
+    machineNickname: options.machineNickname ?? cfg.machineNickname ?? null,
+    timestamp: options.timestamp ?? Date.now(),
+    detectedIdes: buildDetectedIdeInfos(options.detectedIdes, options.cdpManagers),
+    ...options.p2p ? { p2p: options.p2p } : {},
+    sessions,
+    workspaces: wsState.workspaces,
+    defaultWorkspaceId: wsState.defaultWorkspaceId,
+    defaultWorkspacePath: wsState.defaultWorkspacePath,
+    recentLaunches: buildRecentLaunches(recentActivity),
+    terminalBackend,
+    availableProviders: buildAvailableProviders(options.providerLoader)
+  };
+}
+
+// src/commands/router.ts
 import * as fs7 from "fs";
 var CHAT_COMMANDS = [
   "send_chat",
@@ -8393,6 +8548,7 @@ var CHAT_COMMANDS = [
   "set_mode",
   "change_model"
 ];
+var READ_DEBUG_ENABLED2 = process.argv.includes("--dev") || process.env.ADHDEV_READ_DEBUG === "1";
 var DaemonCommandRouter = class {
   deps;
   constructor(deps) {
@@ -8563,28 +8719,35 @@ var DaemonCommandRouter = class {
         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" };
+      case "mark_session_seen": {
+        const sessionId = args?.sessionId;
+        if (!sessionId || typeof sessionId !== "string") {
+          return { success: false, error: "sessionId is 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()
+        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,
-          recentKey,
-          seenAt: next.recentSessionReads?.[recentKey] || Date.now()
+          sessionId,
+          seenAt: next.sessionReads?.[sessionId] || Date.now(),
+          completionMarker
         };
       }
       // ─── Daemon Self-Upgrade ───
@@ -8701,194 +8864,6 @@ var DaemonCommandRouter = class {
 
 // src/status/reporter.ts
 init_logger();
-
-// src/status/snapshot.ts
-init_config();
-import * as os10 from "os";
-init_terminal_screen();
-function buildDetectedIdeInfos(detectedIdes, cdpManagers) {
-  return detectedIdes.filter((ide) => ide.installed !== false).map((ide) => ({
-    id: ide.id,
-    type: ide.id,
-    name: ide.displayName || ide.name || ide.id,
-    running: isCdpConnected(cdpManagers, ide.id),
-    ...ide.path ? { path: ide.path } : {}
-  }));
-}
-function buildAvailableProviders(providerLoader) {
-  return providerLoader.getAll().map((provider) => ({
-    type: provider.type,
-    name: provider.displayName || provider.type,
-    displayName: provider.displayName || provider.type,
-    icon: provider.icon || "\u{1F4BB}",
-    category: provider.category
-  }));
-}
-function parseMessageTime(value) {
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "string") {
-    const parsed = Date.parse(value);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return 0;
-}
-function getSessionMessageUpdatedAt(session) {
-  const lastMessage = session.activeChat?.messages?.at?.(-1);
-  if (!lastMessage) return 0;
-  return parseMessageTime(lastMessage.timestamp) || parseMessageTime(lastMessage.receivedAt) || parseMessageTime(lastMessage.createdAt) || 0;
-}
-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) {
-  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";
-  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, b) => b.lastUsedAt - a.lastUsedAt).slice(0, 12);
-}
-function buildStatusSnapshot(options) {
-  const cfg = loadConfig();
-  const wsState = getWorkspaceState(cfg);
-  const memSnap = getHostMemorySnapshot();
-  const recentActivity = getRecentActivity(cfg, 20);
-  const sessions = buildSessionEntries(
-    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 lastUsedAt = getSessionLastUsedAt(session);
-    const { unread, inboxBucket } = session.surfaceHidden ? { unread: false, inboxBucket: "idle" } : getUnreadState(
-      getSessionMessageUpdatedAt(session) > 0,
-      session.status,
-      lastUsedAt,
-      lastSeenAt,
-      getLastMessageRole(session)
-    );
-    session.recentKey = recentKey;
-    session.lastSeenAt = lastSeenAt;
-    session.unread = unread;
-    session.inboxBucket = inboxBucket;
-  }
-  const terminalBackend = getTerminalBackendRuntimeStatus();
-  return {
-    instanceId: options.instanceId,
-    version: options.version,
-    daemonMode: options.daemonMode,
-    machine: {
-      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(),
-      release: os10.release()
-    },
-    machineNickname: options.machineNickname ?? cfg.machineNickname ?? null,
-    timestamp: options.timestamp ?? Date.now(),
-    detectedIdes: buildDetectedIdeInfos(options.detectedIdes, options.cdpManagers),
-    ...options.p2p ? { p2p: options.p2p } : {},
-    sessions,
-    workspaces: wsState.workspaces,
-    defaultWorkspaceId: wsState.defaultWorkspaceId,
-    defaultWorkspacePath: wsState.defaultWorkspacePath,
-    recentSessions: buildRecentSessions(sessions, recentActivity, readState),
-    terminalBackend,
-    availableProviders: buildAvailableProviders(options.providerLoader)
-  };
-}
-
-// src/status/reporter.ts
 var DaemonStatusReporter = class {
   deps;
   log;
@@ -9036,7 +9011,7 @@ var DaemonStatusReporter = class {
         currentModel: session.currentModel,
         currentPlan: session.currentPlan,
         currentAutoApprove: session.currentAutoApprove,
-        recentKey: session.recentKey,
+        lastUpdated: session.lastUpdated,
         unread: session.unread,
         lastSeenAt: session.lastSeenAt,
         inboxBucket: session.inboxBucket,
@@ -9093,12 +9068,14 @@ init_provider_cli_adapter();
 import * as crypto3 from "crypto";
 init_logger();
 var 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();
@@ -9117,6 +9094,26 @@ var CliProviderInstance = class {
   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;
@@ -9156,7 +9153,8 @@ var CliProviderInstance = class {
       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}`,
@@ -10303,12 +10301,12 @@ var DaemonCliManager = class {
       }
     }, 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(),
@@ -10334,7 +10332,7 @@ var DaemonCliManager = class {
     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(/^~/, os13.homedir()) : path10.resolve(trimmed);
@@ -10426,6 +10424,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;
@@ -10434,14 +10455,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) {
@@ -10549,7 +10571,8 @@ ${installInfo}`
           record.cliArgs,
           resolvedProvider,
           {},
-          true
+          true,
+          record.launchMode
         );
         restored += 1;
         LOG.info("CLI", `\u267B Restored hosted runtime: ${record.runtimeKey || record.runtimeId} (${record.displayName || record.workspace})`);
@@ -10619,7 +10642,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) {