@adhdev/daemon-core 0.7.39 → 0.7.41

package/dist/providers/cli-provider-instance.d.ts

@@ -26,7 +26,16 @@ export declare class CliProviderInstance implements ProviderInstance {
     private lastApprovalEventAt;
     private historyWriter;
     readonly instanceId: string;
-    constructor(provider: ProviderModule, workingDir: string, cliArgs?: string[], instanceId?: string, transportFactory?: PtyTransportFactory);
+    private launchMode;
+    private resolvedOutputFormat;
+    constructor(provider: ProviderModule, workingDir: string, cliArgs?: string[], instanceId?: string, transportFactory?: PtyTransportFactory, launchModeId?: string);
+    /**
+     * Determine output rendering format from:
+     * 1. launchMode.outputFormat (explicit override)
+     * 2. launchOptions[].outputFormatMap — check actual args for matching values
+     * 3. Default: 'terminal'
+     */
+    private resolveOutputFormat;
     init(context: InstanceContext): Promise<void>;
     onTick(): Promise<void>;
     getState(): ProviderState;

package/dist/providers/contracts.d.ts

@@ -245,6 +245,20 @@ export interface ProviderModule {
         shell?: boolean;
         env?: Record<string, string>;
     };
+    /**
+     * Configurable options shown at session launch time (schema declaration).
+     * The frontend renders these as a launch config UI.
+     * Values are passed to launchArgBuilder to produce the final args.
+     */
+    launchOptions?: ProviderLaunchOption[];
+    /**
+     * Builds extra spawn args from user-selected launch option values.
+     * Called with the merged defaults + mode preset + user overrides.
+     * When defined, takes precedence over launchMode.extraArgs.
+     */
+    launchArgBuilder?: (options: Record<string, string | boolean | number>) => string[];
+    /** Named presets — shortcuts that set launchOption values in bulk */
+    launchModes?: ProviderLaunchMode[];
     patterns?: {
         prompt?: RegExp[];
         generating?: RegExp[];
@@ -306,6 +320,71 @@ export interface ProviderModule {
     /** ACP agent auth methods (multiple supported — in priority order) */
     auth?: AcpAuthMethod[];
 }
+export type ProviderLaunchOptionType = 'select' | 'boolean' | 'string' | 'number';
+/**
+ * A single configurable option exposed at session launch time.
+ * Providers declare these so the frontend can render a launch config UI.
+ * The final args are built by launchArgBuilder(selectedValues).
+ *
+ * Example — Claude Code:
+ *   { id: 'outputFormat', type: 'select', options: [
+ *       { value: 'terminal', label: 'Terminal' },
+ *       { value: 'stream-json', label: 'Chat' },
+ *   ], default: 'terminal' }
+ */
+export interface ProviderLaunchOption {
+    /** Unique identifier — key used in launchArgBuilder options map */
+    id: string;
+    /** Display label */
+    name: string;
+    description?: string;
+    type: ProviderLaunchOptionType;
+    /** Options for 'select' type */
+    options?: {
+        value: string;
+        label: string;
+        description?: string;
+    }[];
+    /** Default value — applied when not explicitly set */
+    default?: string | boolean | number;
+    /**
+     * Maps specific values of this option to a frontend rendering hint.
+     * e.g. { 'stream-json': 'stream-json' } tells the UI to switch to Chat mode.
+     */
+    outputFormatMap?: Record<string, 'terminal' | 'stream-json'>;
+}
+/**
+ * A named launch preset — shorthand for a specific set of launchOption values.
+ * When selected, its `options` are merged with user-configured values before
+ * calling launchArgBuilder. Falls back to `extraArgs` if no launchArgBuilder defined.
+ */
+export interface ProviderLaunchMode {
+    /** Unique mode identifier (e.g. 'terminal', 'chat') */
+    id: string;
+    /** Display name */
+    name: string;
+    description?: string;
+    /**
+     * Preset option values — merged over defaults before calling launchArgBuilder.
+     * Keys correspond to ProviderLaunchOption.id.
+     */
+    options?: Record<string, string | boolean | number>;
+    /**
+     * Fallback: raw args appended when no launchArgBuilder is defined.
+     * Use launchArgBuilder + options for anything more than trivial cases.
+     */
+    extraArgs?: string[];
+    /** Env var overrides applied on top of spawn.env */
+    env?: Record<string, string>;
+    /**
+     * Output rendering hint (shorthand when not using launchOptions/outputFormatMap).
+     * - 'terminal' — raw PTY stream (default)
+     * - 'stream-json' — structured JSON events → chat messages
+     */
+    outputFormat?: 'terminal' | 'stream-json';
+    /** Whether this is the default mode when none is specified */
+    default?: boolean;
+}
 export interface ProviderResumeCapability {
     supported: boolean;
     stopStrategy?: 'command' | 'ctrl_c';

package/dist/providers/provider-instance.d.ts

@@ -86,6 +86,8 @@ export interface CliProviderState extends ProviderStateBase {
     category: 'cli';
     /** terminal = PTY stream, chat = parsed conversation */
     mode: 'terminal' | 'chat';
+    /** Active launch mode id (e.g. 'chat') — undefined means default terminal */
+    launchMode?: string;
 }
 /** ACP provider state */
 export interface AcpProviderState extends ProviderStateBase {

package/dist/shared-types-extra.d.ts

@@ -17,7 +17,7 @@ export interface RuntimeAttachedClient {
     type: 'daemon' | 'web' | 'local-terminal';
     readOnly: boolean;
 }
-/** Session status union (used by SessionEntry.status, RecentSessionEntry.status, etc.) */
+/** Session status union (used by SessionEntry.status, legacy recent-launch metadata, etc.) */
 export type SessionStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
 /** Inbox bucket categories for recent sessions */
 export type RecentSessionBucket = 'needs_attention' | 'working' | 'task_complete' | 'idle';

package/dist/shared-types.d.ts

@@ -51,6 +51,10 @@ export interface SessionEntry {
     runtimeKey?: string;
     runtimeDisplayName?: string;
     runtimeWorkspaceLabel?: string;
+    /** CLI only: active launch mode id (e.g. 'terminal', 'chat') */
+    launchMode?: string;
+    /** CLI only: output rendering mode derived from launchMode.outputFormat */
+    mode?: 'terminal' | 'chat';
     runtimeWriteOwner?: RuntimeWriteOwner | null;
     runtimeAttachedClients?: RuntimeAttachedClient[];
     resume?: ProviderResumeCapability;
@@ -69,7 +73,6 @@ export interface SessionEntry {
     errorMessage?: string;
     errorReason?: _ProviderErrorReason;
     lastUpdated?: number;
-    recentKey?: string;
     unread?: boolean;
     lastSeenAt?: number;
     inboxBucket?: RecentSessionBucket;
@@ -161,22 +164,15 @@ export interface DetectedIdeInfo {
 export type { RecentSessionBucket, TerminalBackendStatus } from './shared-types-extra.js';
 import type { RecentSessionBucket } from './shared-types-extra.js';
 import type { TerminalBackendStatus } from './shared-types-extra.js';
-export interface RecentSessionEntry {
+export interface RecentLaunchEntry {
     id: string;
-    recentKey: string;
-    sessionId?: string | null;
     providerType: string;
     providerName: string;
     kind: 'ide' | 'cli' | 'acp';
-    title: string;
+    title?: string;
     workspace?: string | null;
     currentModel?: string;
-    status?: SessionEntry['status'];
-    lastUsedAt: number;
-    unread?: boolean;
-    lastSeenAt?: number;
-    inboxBucket?: RecentSessionBucket;
-    surfaceHidden?: boolean;
+    lastLaunchedAt: number;
 }
 export interface StatusReportPayload {
     /** Unique daemon instance identifier */
@@ -206,7 +202,7 @@ export interface StatusReportPayload {
     workspaces?: WorkspaceEntry[];
     defaultWorkspaceId?: string | null;
     defaultWorkspacePath?: string | null;
-    recentSessions?: RecentSessionEntry[];
+    recentLaunches?: RecentLaunchEntry[];
     terminalBackend?: TerminalBackendStatus;
     /** Available providers (present in StatusSnapshot, optional in raw payload) */
     availableProviders?: AvailableProviderInfo[];

package/dist/status/snapshot.d.ts

@@ -35,4 +35,17 @@ export interface StatusSnapshotOptions {
 export interface StatusSnapshot extends StatusReportPayload {
     availableProviders: AvailableProviderInfo[];
 }
+export declare function getSessionCompletionMarker(session: {
+    activeChat?: {
+        messages?: Array<{
+            role?: string;
+            id?: string;
+            index?: number;
+            timestamp?: number | string;
+            receivedAt?: number | string;
+            createdAt?: number | string;
+            _turnKey?: string;
+        }> | null;
+    } | null;
+}): string;
 export declare function buildStatusSnapshot(options: StatusSnapshotOptions): StatusSnapshot;

package/node_modules/@adhdev/session-host-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.7.39",
+  "version": "0.7.41",
   "description": "ADHDev local session host core — session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.7.39",
+  "version": "0.7.41",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/cli-manager.ts

@@ -60,6 +60,7 @@ export interface HostedCliRuntimeDescriptor {
     cliType: string;
     workspace: string;
     cliArgs?: string[];
+    launchMode?: string;
 }
 
 const chalkApi: any = (chalk as any)?.yellow
@@ -178,12 +179,13 @@ export class DaemonCliManager {
         provider: any,
         settings: Record<string, any>,
         attachExisting = false,
+        launchModeId?: string,
     ): Promise<void> {
         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(),
@@ -212,7 +214,7 @@ export class DaemonCliManager {
 
  // ─── Session start/management ──────────────────────────────
 
-    async startSession(cliType: string, workingDir: string, cliArgs?: string[], initialModel?: string): Promise<void> {
+    async startSession(cliType: string, workingDir: string, cliArgs?: string[], initialModel?: string, launchMode?: string, launchOptionValues?: Record<string, string | boolean | number>): Promise<void> {
         const trimmed = (workingDir || '').trim();
         if (!trimmed) throw new Error('working directory required');
         const resolvedDir = trimmed.startsWith('~')
@@ -318,6 +320,40 @@ export class DaemonCliManager {
             console.log(colorize('cyan', `  📦 Using provider: ${provider.name} (${provider.type})`));
         }
 
+ // ─── Resolve launch options → extra args ───
+        let resolvedCliArgs = cliArgs;
+        let resolvedLaunchMode = launchMode;
+
+        const activeMode = provider?.launchModes?.length
+            ? (launchMode
+                ? provider.launchModes.find((m: any) => m.id === launchMode)
+                : provider.launchModes.find((m: any) => m.default))
+            : undefined;
+
+        if (activeMode) {
+            resolvedLaunchMode = activeMode.id;
+        }
+
+        if (provider?.launchArgBuilder) {
+            // Build option values: schema defaults → mode preset → user args?.launchOptionValues
+            const defaults: Record<string, string | boolean | number> = {};
+            for (const opt of (provider.launchOptions || [])) {
+                if (opt.default !== undefined) defaults[opt.id] = opt.default;
+            }
+            const modeOptions: Record<string, string | boolean | number> = activeMode?.options || {};
+            const userOptions: Record<string, string | boolean | number> = launchOptionValues || {};
+            const merged = { ...defaults, ...modeOptions, ...userOptions };
+            const extraArgs = provider.launchArgBuilder(merged);
+            if (extraArgs.length) {
+                resolvedCliArgs = [...(cliArgs || []), ...extraArgs];
+                console.log(colorize('cyan', `  🚀 Launch options applied: ${extraArgs.join(' ')}`));
+            }
+        } else if (activeMode?.extraArgs?.length) {
+            // Fallback: simple extraArgs from mode (no launchArgBuilder)
+            resolvedCliArgs = [...(cliArgs || []), ...activeMode.extraArgs];
+            console.log(colorize('cyan', `  🚀 Launch mode '${activeMode.name}': appending args ${activeMode.extraArgs.join(' ')}`));
+        }
+
  // If InstanceManager exists, manage as CliProviderInstance unified
         const instanceManager = this.deps.getInstanceManager();
         if (provider && instanceManager) {
@@ -327,15 +363,16 @@ export class DaemonCliManager {
                 normalizedType,
                 cliType,
                 resolvedDir,
-                cliArgs,
+                resolvedCliArgs,
                 resolvedProvider,
                 {},
                 false,
+                resolvedLaunchMode,
             );
             console.log(colorize('green', `  ✓ CLI started: ${cliInfo.displayName} v${cliInfo.version || 'unknown'} in ${resolvedDir}`));
         } else {
  // Fallback: InstanceManager without directly adapter manage
-            const adapter = this.createAdapter(cliType, resolvedDir, cliArgs, key, false);
+            const adapter = this.createAdapter(cliType, resolvedDir, resolvedCliArgs, key, false);
             try {
                 await adapter.spawn();
             } catch (spawnErr: any) {
@@ -458,6 +495,7 @@ export class DaemonCliManager {
                     resolvedProvider,
                     {},
                     true,
+                    record.launchMode,
                 );
                 restored += 1;
                 LOG.info('CLI', `♻ Restored hosted runtime: ${record.runtimeKey || record.runtimeId} (${record.displayName || record.workspace})`);
@@ -537,7 +575,7 @@ export class DaemonCliManager {
                 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);
 
  // On startSession success, new UUID key exists in adapters (last added item)
                 let newKey: string | null = null;

package/src/commands/router.ts

@@ -18,12 +18,14 @@ import type { ProviderInstanceManager } from '../providers/provider-instance-man
 import { launchWithCdp, killIdeProcess, isIdeRunning } from '../launch.js';
 import { loadConfig, saveConfig, updateConfig } from '../config/config.js';
 import { resolveIdeLaunchWorkspace } from '../config/workspaces.js';
-import { appendRecentActivity, buildRecentActivityKey, markRecentSessionSeen } from '../config/recent-activity.js';
+import { appendRecentActivity, markSessionSeen } from '../config/recent-activity.js';
 import { detectIDEs } from '../detection/ide-detector.js';
 import { SessionRegistry } from '../sessions/registry.js';
 import { LOG } from '../logging/logger.js';
 import { logCommand } from '../logging/command-log.js';
 import { getRecentLogs, LOG_PATH } from '../logging/logger.js';
+import { buildSessionEntries } from '../status/builders.js';
+import { getSessionCompletionMarker } from '../status/snapshot.js';
 import * as fs from 'fs';
 
 // ─── Types ───
@@ -61,6 +63,7 @@ const CHAT_COMMANDS = [
     'send_chat', 'new_chat', 'switch_chat', 'set_mode',
     'change_model',
 ];
+const READ_DEBUG_ENABLED = process.argv.includes('--dev') || process.env.ADHDEV_READ_DEBUG === '1';
 
 export class DaemonCommandRouter {
     private deps: CommandRouterDeps;
@@ -265,28 +268,35 @@ export class DaemonCommandRouter {
                 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,
+                const currentConfig = loadConfig();
+                const prevSeenAt = currentConfig.sessionReads?.[sessionId] || 0;
+                const sessionEntries = buildSessionEntries(
+                    this.deps.instanceManager.collectAllStates(),
+                    this.deps.cdpManagers as Map<string, any>,
+                );
+                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_ENABLED) {
+                    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,
                 };
             }
 

package/src/config/config.ts

@@ -59,8 +59,10 @@ export interface ADHDevConfig {
 
     /** Unified recent activity across IDE / CLI / ACP launch flows */
     recentActivity?: RecentActivityEntry[];
-    /** Last seen timestamps for machine-facing recent/session entries */
-    recentSessionReads?: Record<string, number>;
+    /** Last seen timestamps for live sessions, keyed by sessionId */
+    sessionReads?: Record<string, number>;
+    /** Last seen completion marker for live sessions, keyed by sessionId */
+    sessionReadMarkers?: Record<string, string>;
 
  // Machine nickname (user-customizable label for this machine)
     machineNickname: string | null;
@@ -122,7 +124,8 @@ const DEFAULT_CONFIG: ADHDevConfig = {
     workspaces: [],
     defaultWorkspaceId: null,
     recentActivity: [],
-    recentSessionReads: {},
+    sessionReads: {},
+    sessionReadMarkers: {},
     machineNickname: null,
     machineId: undefined,
     machineSecret: null,

package/src/config/recent-activity.ts

@@ -1,10 +1,10 @@
 /**
- * Unified recent activity — machine-facing "pick up where you left off".
+ * Unified recent activity — launcher-facing "pick up where you launched".
  *
- * Unlike cliHistory or workspaceActivity, this is task/session oriented:
+ * Unlike live session state, this is launch oriented:
  * - one normalized row shape for IDE / CLI / ACP
  * - deduped by kind + providerType + workspace
- * - optionally linked to a live sessionId when known
+ * - used only for quick-launch shortcuts
  */
 
 import * as path from 'path';
@@ -18,7 +18,6 @@ export interface RecentActivityEntry {
     providerName: string;
     workspace?: string | null;
     currentModel?: string;
-    sessionId?: string | null;
     title?: string;
     lastUsedAt: number;
 }
@@ -62,22 +61,35 @@ export function getRecentActivity(config: ADHDevConfig, limit = 20): RecentActiv
         .slice(0, limit);
 }
 
-export function getRecentSessionSeenAt(config: ADHDevConfig, recentKey: string): number {
-    return config.recentSessionReads?.[recentKey] || 0;
+export function getSessionSeenAt(config: ADHDevConfig, sessionId: string): number {
+    return config.sessionReads?.[sessionId] || 0;
 }
 
-export function markRecentSessionSeen(
+export function getSessionSeenMarker(config: ADHDevConfig, sessionId: string): string {
+    return config.sessionReadMarkers?.[sessionId] || '';
+}
+
+export function markSessionSeen(
     config: ADHDevConfig,
-    recentKey: string,
+    sessionId: string,
     seenAt = Date.now(),
+    completionMarker?: string | null,
 ): ADHDevConfig {
-    const prev = config.recentSessionReads || {};
-    const nextSeenAt = Math.max(prev[recentKey] || 0, seenAt);
+    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,
     };
 }

package/src/index.ts

@@ -46,11 +46,11 @@ export type {
 // rollup-dts cannot resolve re-exports from shared-types.ts for them.
 import type { RuntimeWriteOwner as _RuntimeWriteOwner } from './shared-types-extra.js';
 import type { RuntimeAttachedClient as _RuntimeAttachedClient } from './shared-types-extra.js';
-import type { RecentSessionEntry as _RecentSessionEntry } from './shared-types.js';
+import type { RecentLaunchEntry as _RecentLaunchEntry } from './shared-types.js';
 import type { TerminalBackendStatus as _TerminalBackendStatus } from './shared-types-extra.js';
 export type RuntimeWriteOwner = _RuntimeWriteOwner;
 export type RuntimeAttachedClient = _RuntimeAttachedClient;
-export type RecentSessionEntry = _RecentSessionEntry;
+export type RecentLaunchEntry = _RecentLaunchEntry;
 export type TerminalBackendStatus = _TerminalBackendStatus;
 
 // Type aliases — rollup-dts cannot bundle re-exported type aliases at all.

package/src/providers/cli-provider-instance.ts

@@ -7,7 +7,7 @@
 
 import * as path from 'path';
 import * as crypto from 'crypto';
-import type { ProviderModule } from './contracts.js';
+import type { ProviderModule, ProviderLaunchMode, ProviderLaunchOption } from './contracts.js';
 import type { ProviderInstance, ProviderState, ProviderEvent, InstanceContext } from './provider-instance.js';
 import { ProviderCliAdapter } from '../cli-adapters/provider-cli-adapter.js';
 import type { CliProviderModule } from '../cli-adapters/provider-cli-adapter.js';
@@ -33,20 +33,46 @@ export class CliProviderInstance implements ProviderInstance {
     private historyWriter: ChatHistoryWriter;
     readonly instanceId: string;
 
+    private launchMode: ProviderLaunchMode | null;
+    private resolvedOutputFormat: 'terminal' | 'stream-json';
+
     constructor(
         private provider: ProviderModule,
         private workingDir: string,
         private cliArgs: string[] = [],
         instanceId?: string,
         transportFactory?: PtyTransportFactory,
+        launchModeId?: string,
     ) {
         this.type = provider.type;
         this.instanceId = instanceId || crypto.randomUUID();
+        this.launchMode = (launchModeId && provider.launchModes?.find(m => m.id === launchModeId)) || null;
+        this.resolvedOutputFormat = this.resolveOutputFormat();
         this.adapter = new ProviderCliAdapter(provider as any as CliProviderModule, workingDir, cliArgs, transportFactory);
         this.monitor = new StatusMonitor();
         this.historyWriter = new ChatHistoryWriter();
     }
 
+    /**
+     * Determine output rendering format from:
+     * 1. launchMode.outputFormat (explicit override)
+     * 2. launchOptions[].outputFormatMap — check actual args for matching values
+     * 3. Default: 'terminal'
+     */
+    private resolveOutputFormat(): 'terminal' | 'stream-json' {
+        if (this.launchMode?.outputFormat) return this.launchMode.outputFormat;
+        if (this.provider.launchOptions?.length) {
+            for (const opt of this.provider.launchOptions) {
+                if (!opt.outputFormatMap) continue;
+                // Check if any cliArg matches a value with an outputFormatMap entry
+                for (const [val, fmt] of Object.entries(opt.outputFormatMap)) {
+                    if (this.cliArgs.includes(val)) return fmt;
+                }
+            }
+        }
+        return 'terminal';
+    }
+
  // ─── Lifecycle ─────────────────────────────────
 
     async init(context: InstanceContext): Promise<void> {
@@ -102,7 +128,8 @@ export class CliProviderInstance implements ProviderInstance {
             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} · ${dirName}`,