@adhdev/daemon-core 0.7.40 → 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.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;

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

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.7.40",
+  "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.40",
+  "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/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}`,

package/src/providers/contracts.ts

@@ -317,6 +317,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[];
@@ -393,6 +407,72 @@ export interface ProviderModule {
   auth?: AcpAuthMethod[];
 }
 
+// ─── CLI Launch Options (individual configurable flags) ────────────────
+
+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/src/providers/provider-instance.ts

@@ -103,6 +103,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 */

package/src/shared-types.ts

@@ -102,6 +102,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;

package/src/status/builders.ts

@@ -265,6 +265,8 @@ function buildCliSession(state: CliProviderState): SessionEntry {
         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,