@adhdev/daemon-core 0.7.41 → 0.7.42

package/src/commands/cli-manager.ts

@@ -60,7 +60,6 @@ export interface HostedCliRuntimeDescriptor {
     cliType: string;
     workspace: string;
     cliArgs?: string[];
-    launchMode?: string;
 }
 
 const chalkApi: any = (chalk as any)?.yellow
@@ -91,6 +90,19 @@ export class DaemonCliManager {
         return `${cliType}_${hash}`;
     }
 
+    getSessionPresentationMode(sessionId: string): 'terminal' | 'chat' | null {
+        if (!sessionId) return null;
+        const instance = this.deps.getInstanceManager()?.getInstance(sessionId) as any;
+        const mode = instance?.category === 'cli'
+            ? instance.getPresentationMode?.()
+            : null;
+        return mode === 'chat' || mode === 'terminal' ? mode : null;
+    }
+
+    isTerminalSession(sessionId: string): boolean {
+        return this.getSessionPresentationMode(sessionId) === 'terminal';
+    }
+
     private persistRecentActivity(entry: {
         kind: 'ide' | 'cli' | 'acp';
         providerType: string;
@@ -179,13 +191,12 @@ 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, launchModeId);
+        const cliInstance = new CliProviderInstance(provider, resolvedDir, cliArgs, key, transportFactory);
         try {
             await instanceManager.addInstance(key, cliInstance, {
                 serverConn: this.deps.getServerConn(),
@@ -214,7 +225,7 @@ export class DaemonCliManager {
 
  // ─── Session start/management ──────────────────────────────
 
-    async startSession(cliType: string, workingDir: string, cliArgs?: string[], initialModel?: string, launchMode?: string, launchOptionValues?: Record<string, string | boolean | number>): Promise<void> {
+    async startSession(cliType: string, workingDir: string, cliArgs?: string[], initialModel?: string): Promise<void> {
         const trimmed = (workingDir || '').trim();
         if (!trimmed) throw new Error('working directory required');
         const resolvedDir = trimmed.startsWith('~')
@@ -321,38 +332,7 @@ export class DaemonCliManager {
         }
 
  // ─── 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(' ')}`));
-        }
+        const resolvedCliArgs = cliArgs;
 
  // If InstanceManager exists, manage as CliProviderInstance unified
         const instanceManager = this.deps.getInstanceManager();
@@ -367,7 +347,6 @@ export class DaemonCliManager {
                 resolvedProvider,
                 {},
                 false,
-                resolvedLaunchMode,
             );
             console.log(colorize('green', `  ✓ CLI started: ${cliInfo.displayName} v${cliInfo.version || 'unknown'} in ${resolvedDir}`));
         } else {
@@ -495,7 +474,6 @@ export class DaemonCliManager {
                     resolvedProvider,
                     {},
                     true,
-                    record.launchMode,
                 );
                 restored += 1;
                 LOG.info('CLI', `♻ Restored hosted runtime: ${record.runtimeKey || record.runtimeId} (${record.displayName || record.workspace})`);
@@ -545,6 +523,15 @@ export class DaemonCliManager {
         return null;
     }
 
+    private findAdapterBySessionId(instanceKey?: string): { adapter: CliAdapter; key: string } | null {
+        if (!instanceKey) return null;
+        let ik = instanceKey;
+        const colonIdx = ik.lastIndexOf(':');
+        if (colonIdx >= 0) ik = ik.substring(colonIdx + 1);
+        const adapter = this.adapters.get(ik);
+        return adapter ? { adapter, key: ik } : null;
+    }
+
  // ─── CLI command handling ────────────────────────────
 
     async handleCliCommand(cmd: string, args: any): Promise<CommandResult | null> {
@@ -575,7 +562,7 @@ export class DaemonCliManager {
                 const launchSource = resolved.source;
                 if (!cliType) throw new Error('cliType required');
 
-                await this.startSession(cliType, dir, args?.cliArgs, args?.initialModel, args?.launchMode, args?.launchOptionValues);
+                await this.startSession(cliType, dir, args?.cliArgs, args?.initialModel);
 
  // On startSession success, new UUID key exists in adapters (last added item)
                 let newKey: string | null = null;
@@ -601,6 +588,24 @@ export class DaemonCliManager {
                 }
                 return { success: true, cliType, dir, stopped: true, mode };
             }
+            case 'set_cli_view_mode': {
+                const mode = args?.mode === 'chat' ? 'chat' : 'terminal';
+                const targetSessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId : '';
+                const cliType = args?.cliType || args?.agentType || '';
+                const dir = args?.dir || '';
+                const found = this.findAdapterBySessionId(targetSessionId)
+                    || (cliType ? this.findAdapter(cliType, { instanceKey: targetSessionId, dir }) : null);
+                if (!found) {
+                    return { success: false, error: 'CLI session not found', code: 'CLI_SESSION_NOT_FOUND' };
+                }
+                const instance = this.deps.getInstanceManager()?.getInstance(found.key);
+                if (!(instance instanceof CliProviderInstance)) {
+                    return { success: false, error: 'CLI instance not found', code: 'CLI_INSTANCE_NOT_FOUND' };
+                }
+                instance.setPresentationMode(mode);
+                this.deps.onStatusChange();
+                return { success: true, id: found.key, mode };
+            }
             case 'restart_session': {
                 const cliType = args?.cliType || args?.agentType || args?.ideType;
                 const cfg = loadConfig();

package/src/commands/router.ts

@@ -121,6 +121,7 @@ export class DaemonCommandRouter {
             // ─── CLI / ACP commands ───
             case 'launch_cli':
             case 'stop_cli':
+            case 'set_cli_view_mode':
             case 'agent_command': {
                 return this.deps.cliManager.handleCliCommand(cmd, args);
             }

package/src/commands/stream-commands.ts

@@ -7,6 +7,14 @@ import type { CommandResult, CommandHelpers } from './handler.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import { LOG } from '../logging/logger.js';
 
+function getCliPresentationMode(h: CommandHelpers, targetSessionId?: string): 'terminal' | 'chat' | null {
+    if (!targetSessionId) return null;
+    const instance = h.ctx.instanceManager?.getInstance(targetSessionId) as any;
+    if (instance?.category !== 'cli') return null;
+    const mode = instance.getPresentationMode?.();
+    return mode === 'chat' || mode === 'terminal' ? mode : null;
+}
+
 export async function handleFocusSession(h: CommandHelpers, args: any): Promise<CommandResult> {
     if (!h.agentStream || !h.getCdp()) return { success: false, error: 'AgentStream or CDP not available' };
     const sessionId = args?.targetSessionId || h.currentSession?.sessionId;
@@ -20,6 +28,9 @@ export async function handleFocusSession(h: CommandHelpers, args: any): Promise<
 export function handlePtyInput(h: CommandHelpers, args: any): CommandResult {
     const { cliType, data, targetSessionId } = args || {};
     if (!data) return { success: false, error: 'data required' };
+    if (getCliPresentationMode(h, targetSessionId) === 'chat') {
+        return { success: false, error: 'CLI session is in chat mode', code: 'CLI_VIEW_MODE_NOT_TERMINAL' };
+    }
     const adapter = h.getCliAdapter(targetSessionId || cliType);
     if (!adapter || typeof adapter.writeRaw !== 'function') {
         return { success: false, error: `CLI adapter not found: ${targetSessionId || cliType || 'unknown'}` };
@@ -31,6 +42,9 @@ export function handlePtyInput(h: CommandHelpers, args: any): CommandResult {
 export function handlePtyResize(h: CommandHelpers, args: any): CommandResult {
     const { cliType, cols, rows, force, targetSessionId } = args || {};
     if (!cols || !rows) return { success: false, error: 'cols and rows required' };
+    if (getCliPresentationMode(h, targetSessionId) === 'chat') {
+        return { success: false, error: 'CLI session is in chat mode', code: 'CLI_VIEW_MODE_NOT_TERMINAL' };
+    }
     const adapter = h.getCliAdapter(targetSessionId || cliType);
     if (!adapter || typeof adapter.resize !== 'function') {
         return { success: false, error: `CLI adapter not found: ${targetSessionId || cliType || 'unknown'}` };

package/src/config/config.d.ts

@@ -1,65 +1,39 @@
 /**
  * ADHDev Launcher — Configuration
  *
- * Manages launcher config, server connection tokens, and user preferences.
+ * Manages launcher config, machine auth, and user preferences.
  */
 import type { WorkspaceEntry } from './workspaces.js';
-import type { WorkspaceActivityEntry } from './workspace-activity.js';
 import type { RecentActivityEntry } from './recent-activity.js';
 export type { WorkspaceEntry } from './workspaces.js';
-export type { WorkspaceActivityEntry } from './workspace-activity.js';
 export type { RecentActivityEntry } from './recent-activity.js';
 export interface ADHDevConfig {
     serverUrl: string;
-    apiToken: string | null;
-    connectionToken: string | null;
     selectedIde: string | null;
     configuredIdes: string[];
     installedExtensions: string[];
-    autoConnect: boolean;
-    /**
-     * @deprecated Not read at runtime. Notification preferences are now managed by:
-     * - Web UI layer: useNotificationPrefs (localStorage)
-     * - Daemon layer: per-provider settings (approvalAlert, longGeneratingAlert)
-     * Kept for backward config compat — will be removed in v0.7+.
-     */
-    notifications: boolean;
     userEmail: string | null;
     userName: string | null;
     setupCompleted: boolean;
     setupDate: string | null;
-    configuredCLIs: string[];
     enabledIdes: string[];
-    recentCliWorkspaces: string[];
     /** Saved workspaces for IDE/CLI/ACP launch (daemon-local) */
     workspaces?: WorkspaceEntry[];
     /** Default workspace id (from workspaces[]) — never used implicitly for launch */
     defaultWorkspaceId?: string | null;
-    /** Recently used workspaces (IDE / CLI / ACP / default) for quick resume */
-    recentWorkspaceActivity?: WorkspaceActivityEntry[];
     /** Unified recent activity across IDE / CLI / ACP launch flows */
     recentActivity?: RecentActivityEntry[];
+    /** 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>;
     machineNickname: string | null;
     /**
      * Stable local machine ID (prefix: `mach_`) — generated locally on first run.
      * Used as daemon instance key (`daemon_<machineId>`) and in status reports.
-     * NOT the same as the server-side D1 `machines.id` — see `registeredMachineId`.
      */
     machineId?: string;
     machineSecret?: string | null;
-    /**
-     * Server-side D1 `machines.id` — the row ID assigned when daemon registers via
-     * `POST /cli/complete`. Corresponds to `machineId` in server DO context
-     * (`DaemonConnection.machineId`, `StatusContext.machineId`).
-     *
-     * Naming differs from server-side `machineId` to avoid confusion with the local
-     * `config.machineId` (mach_ prefix) which is a different value.
-     *
-     * @deprecated Legacy bridge field — will be removed after 2026-04-06.
-     * Modern auth flow uses `machineSecret` (adm_) to identify machines.
-     */
-    registeredMachineId?: string;
-    cliHistory: CliHistoryEntry[];
     providerSettings: Record<string, Record<string, any>>;
     ideSettings: Record<string, {
         extensions?: Record<string, {
@@ -69,17 +43,6 @@ export interface ADHDevConfig {
     disableUpstream?: boolean;
     providerDir?: string;
 }
-export interface CliHistoryEntry {
-    category?: 'ide' | 'cli' | 'acp';
-    cliType: string;
-    dir: string;
-    cliArgs?: string[];
-    workspace?: string;
-    newWindow?: boolean;
-    model?: string;
-    timestamp: number;
-    label?: string;
-}
 export declare function generateMachineId(): string;
 export declare function isStableMachineId(machineId?: string | null): boolean;
 /**
@@ -110,11 +73,3 @@ export declare function isSetupComplete(): boolean;
  * Reset configuration
  */
 export declare function resetConfig(): void;
-/**
- * Generate a connection token for server authentication
- */
-export declare function generateConnectionToken(): string;
-/**
- * Add launch to history (max 20, dedup by category+type+dir+args+workspace+model)
- */
-export declare function addCliHistory(entry: Omit<CliHistoryEntry, 'timestamp'>): void;

package/src/config/config.ts

@@ -1,7 +1,7 @@
 /**
  * ADHDev Launcher — Configuration
- * 
- * Manages launcher config, server connection tokens, and user preferences.
+ *
+ * Manages launcher config, machine auth, and user preferences.
  */
 
 import { homedir } from 'os';
@@ -16,8 +16,6 @@ export type { RecentActivityEntry } from './recent-activity.js';
 export interface ADHDevConfig {
  // Server connection
     serverUrl: string;
-    apiToken: string | null;
-    connectionToken: string | null;
 
  // Selected IDE (primary)
     selectedIde: string | null;
@@ -28,16 +26,6 @@ export interface ADHDevConfig {
  // Installed extensions
     installedExtensions: string[];
 
- // User preferences
-    autoConnect: boolean;
-    /**
-     * @deprecated Not read at runtime. Notification preferences are now managed by:
-     * - Web UI layer: useNotificationPrefs (localStorage)
-     * - Daemon layer: per-provider settings (approvalAlert, longGeneratingAlert)
-     * Kept for backward config compat — will be removed in v0.7+.
-     */
-    notifications: boolean;
-
  // Auth
     userEmail: string | null;
     userName: string | null;
@@ -46,9 +34,6 @@ export interface ADHDevConfig {
     setupCompleted: boolean;
     setupDate: string | null;
 
- // Configured CLI agents
-    configuredCLIs: string[];
-
  // Daemon: which IDEs to connect (empty = all)
     enabledIdes: string[];
 
@@ -70,20 +55,15 @@ export interface ADHDevConfig {
     /**
      * Stable local machine ID (prefix: `mach_`) — generated locally on first run.
      * Used as daemon instance key (`daemon_<machineId>`) and in status reports.
-     * NOT the same as the server-side D1 `machines.id` — see `registeredMachineId`.
      */
     machineId?: string;
 
- // Machine secret for server auth (replaces connectionToken)
+ // Machine secret for server auth
     machineSecret?: string | null;
 
     /**
      * Server-side D1 `machines.id` — the row ID assigned when daemon registers via
-     * `POST /cli/complete`. Corresponds to `machineId` in server DO context
-     * (`DaemonConnection.machineId`, `StatusContext.machineId`).
-     *
-     * Naming differs from server-side `machineId` to avoid confusion with the local
-     * `config.machineId` (mach_ prefix) which is a different value.
+     * `POST /cli/complete`. Used as fallback for machine lookup on re-auth.
      *
      * @deprecated Legacy bridge field — will be removed after 2026-04-06.
      * Modern auth flow uses `machineSecret` (adm_) to identify machines.
@@ -108,18 +88,13 @@ export interface ADHDevConfig {
 
 const DEFAULT_CONFIG: ADHDevConfig = {
     serverUrl: 'https://api.adhf.dev',
-    apiToken: null,
-    connectionToken: null,
     selectedIde: null,
     configuredIdes: [],
     installedExtensions: [],
-    autoConnect: true,
-    notifications: true,
     userEmail: null,
     userName: null,
     setupCompleted: false,
     setupDate: null,
-    configuredCLIs: [],
     enabledIdes: [],
     workspaces: [],
     defaultWorkspaceId: null,
@@ -137,6 +112,68 @@ const DEFAULT_CONFIG: ADHDevConfig = {
 
 const MACHINE_ID_PREFIX = 'mach_';
 
+function isPlainObject(value: unknown): value is Record<string, any> {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function asStringArray(value: unknown): string[] {
+    if (!Array.isArray(value)) return [];
+    return value.filter((item): item is string => typeof item === 'string');
+}
+
+function asNullableString(value: unknown): string | null {
+    return typeof value === 'string' ? value : null;
+}
+
+function asOptionalString(value: unknown): string | undefined {
+    return typeof value === 'string' && value.trim() ? value : undefined;
+}
+
+function asBoolean(value: unknown, fallback: boolean): boolean {
+    return typeof value === 'boolean' ? value : fallback;
+}
+
+function normalizeConfig(raw: unknown): ADHDevConfig & { activeWorkspaceId?: string | null } {
+    const parsed = isPlainObject(raw) ? raw : {};
+    const legacySessionReads = isPlainObject(parsed.recentSessionReads) ? parsed.recentSessionReads : {};
+    const sessionReads = isPlainObject(parsed.sessionReads) ? parsed.sessionReads : {};
+    const mergedSessionReads = Object.fromEntries(
+        Object.entries({ ...legacySessionReads, ...sessionReads })
+            .filter(([, value]) => typeof value === 'number' && Number.isFinite(value))
+    );
+    const sessionReadMarkers = Object.fromEntries(
+        Object.entries(isPlainObject(parsed.sessionReadMarkers) ? parsed.sessionReadMarkers : {})
+            .filter(([, value]) => typeof value === 'string')
+    );
+
+    return {
+        serverUrl: typeof parsed.serverUrl === 'string' && parsed.serverUrl.trim()
+            ? parsed.serverUrl
+            : DEFAULT_CONFIG.serverUrl,
+        selectedIde: asNullableString(parsed.selectedIde),
+        configuredIdes: asStringArray(parsed.configuredIdes),
+        installedExtensions: asStringArray(parsed.installedExtensions),
+        userEmail: asNullableString(parsed.userEmail),
+        userName: asNullableString(parsed.userName),
+        setupCompleted: asBoolean(parsed.setupCompleted, DEFAULT_CONFIG.setupCompleted),
+        setupDate: asNullableString(parsed.setupDate),
+        enabledIdes: asStringArray(parsed.enabledIdes),
+        workspaces: Array.isArray(parsed.workspaces) ? parsed.workspaces as WorkspaceEntry[] : [],
+        defaultWorkspaceId: asNullableString(parsed.defaultWorkspaceId) ?? asNullableString(parsed.activeWorkspaceId),
+        recentActivity: Array.isArray(parsed.recentActivity) ? parsed.recentActivity as RecentActivityEntry[] : [],
+        sessionReads: mergedSessionReads,
+        sessionReadMarkers,
+        machineNickname: asNullableString(parsed.machineNickname),
+        machineId: asOptionalString(parsed.machineId),
+        machineSecret: parsed.machineSecret === null ? null : asOptionalString(parsed.machineSecret),
+        registeredMachineId: asOptionalString(parsed.registeredMachineId),
+        providerSettings: isPlainObject(parsed.providerSettings) ? parsed.providerSettings : {},
+        ideSettings: isPlainObject(parsed.ideSettings) ? parsed.ideSettings : {},
+        disableUpstream: asBoolean(parsed.disableUpstream, DEFAULT_CONFIG.disableUpstream ?? false),
+        providerDir: asOptionalString(parsed.providerDir),
+    };
+}
+
 export function generateMachineId(): string {
     return `${MACHINE_ID_PREFIX}${randomUUID().replace(/-/g, '')}`;
 }
@@ -201,14 +238,10 @@ export function loadConfig(): ADHDevConfig {
     try {
         const raw = readFileSync(configPath, 'utf-8');
         const parsed = JSON.parse(raw);
-        const merged = { ...DEFAULT_CONFIG, ...parsed } as ADHDevConfig & { activeWorkspaceId?: string | null };
-        if (merged.defaultWorkspaceId == null && merged.activeWorkspaceId != null) {
-            (merged as ADHDevConfig).defaultWorkspaceId = merged.activeWorkspaceId;
-        }
-        delete (merged as any).activeWorkspaceId;
-        const ensured = ensureMachineId(merged);
+        const normalizedInput = normalizeConfig(parsed);
+        const ensured = ensureMachineId(normalizedInput);
         const normalized = ensured.config as ADHDevConfig & { activeWorkspaceId?: string | null };
-        if (ensured.changed) {
+        if (ensured.changed || JSON.stringify(parsed) !== JSON.stringify(normalized)) {
             try {
                 saveConfig(normalized);
             } catch { /* ignore */ }
@@ -226,12 +259,13 @@ export function loadConfig(): ADHDevConfig {
 export function saveConfig(config: ADHDevConfig): void {
     const configPath = getConfigPath();
     const dir = getConfigDir();
+    const normalized = normalizeConfig(config);
 
     if (!existsSync(dir)) {
         mkdirSync(dir, { recursive: true, mode: 0o700 });
     }
 
-    writeFileSync(configPath, JSON.stringify(config, null, 2), { encoding: 'utf-8', mode: 0o600 });
+    writeFileSync(configPath, JSON.stringify(normalized, null, 2), { encoding: 'utf-8', mode: 0o600 });
     try { chmodSync(configPath, 0o600); } catch { /* Windows etc. not supported */ }
 }
 
@@ -276,15 +310,3 @@ export function isSetupComplete(): boolean {
 export function resetConfig(): void {
     saveConfig({ ...DEFAULT_CONFIG });
 }
-
-/**
- * Generate a connection token for server authentication
- */
-export function generateConnectionToken(): string {
-    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-    let token = 'db_';
-    for (let i = 0; i < 32; i++) {
-        token += chars.charAt(Math.floor(Math.random() * chars.length));
-    }
-    return token;
-}

package/src/config/workspaces.d.ts

@@ -17,10 +17,7 @@ export declare function validateWorkspacePath(absPath: string): {
 };
 /** Default workspace label from path */
 export declare function defaultWorkspaceLabel(absPath: string): string;
-/**
- * Ensure config.workspaces exists; seed from recentCliWorkspaces once (same paths).
- */
-export declare function migrateWorkspacesFromRecent(config: ADHDevConfig): ADHDevConfig;
+
 export declare function getDefaultWorkspacePath(config: ADHDevConfig): string | null;
 export declare function getWorkspaceState(config: ADHDevConfig): {
     workspaces: WorkspaceEntry[];

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

@@ -7,7 +7,7 @@
 
 import * as path from 'path';
 import * as crypto from 'crypto';
-import type { ProviderModule, ProviderLaunchMode, ProviderLaunchOption } from './contracts.js';
+import type { ProviderModule } 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,8 +33,7 @@ export class CliProviderInstance implements ProviderInstance {
     private historyWriter: ChatHistoryWriter;
     readonly instanceId: string;
 
-    private launchMode: ProviderLaunchMode | null;
-    private resolvedOutputFormat: 'terminal' | 'stream-json';
+    private presentationMode: 'terminal' | 'chat';
 
     constructor(
         private provider: ProviderModule,
@@ -42,37 +41,15 @@ export class CliProviderInstance implements ProviderInstance {
         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.presentationMode = 'terminal';
         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> {
@@ -110,6 +87,7 @@ export class CliProviderInstance implements ProviderInstance {
 
     getState(): ProviderState {
         const adapterStatus = this.adapter.getStatus();
+        const parsedStatus = this.adapter.getScriptParsedStatus?.() || null;
         const runtime = this.adapter.getRuntimeMetadata();
 
         const dirName = this.workingDir.split('/').filter(Boolean).pop() || 'session';
@@ -128,14 +106,13 @@ export class CliProviderInstance implements ProviderInstance {
             name: this.provider.name,
             category: 'cli',
             status: adapterStatus.status,
-            mode: this.resolvedOutputFormat === 'stream-json' ? 'chat' : 'terminal',
-            launchMode: this.launchMode?.id,
+            mode: this.presentationMode,
             activeChat: {
                 id: `${this.type}_${this.workingDir}`,
-                title: `${this.provider.name} · ${dirName}`,
-                status: adapterStatus.status,
-                messages: [],
-                activeModal: adapterStatus.activeModal,
+                title: parsedStatus?.title || `${this.provider.name} · ${dirName}`,
+                status: parsedStatus?.status || adapterStatus.status,
+                messages: Array.isArray(parsedStatus?.messages) ? parsedStatus.messages : [],
+                activeModal: parsedStatus?.activeModal ?? adapterStatus.activeModal,
                 terminalHistory: adapterStatus.terminalHistory,
                 inputContent: '',
             },
@@ -158,6 +135,15 @@ export class CliProviderInstance implements ProviderInstance {
         };
     }
 
+    setPresentationMode(mode: 'terminal' | 'chat'): void {
+        if (this.presentationMode === mode) return;
+        this.presentationMode = mode;
+    }
+
+    getPresentationMode(): 'terminal' | 'chat' {
+        return this.presentationMode;
+    }
+
     onEvent(event: string, data?: any): void {
         if (event === 'send_message' && data?.text) {
             void this.adapter.sendMessage(data.text).catch((e: any) => {