@adhdev/daemon-core 0.7.39 → 0.7.41

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-extra.ts

@@ -20,7 +20,7 @@ export interface RuntimeAttachedClient {
     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 */

package/src/shared-types.d.ts

@@ -147,17 +147,15 @@ export interface WorkspaceActivity {
     kind?: string;
     agentType?: string;
 }
-export interface RecentSessionEntry {
+export interface RecentLaunchEntry {
     id: 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;
+    lastLaunchedAt: number;
 }
 export interface StatusReportPayload {
     /** Daemon instance ID */
@@ -188,5 +186,5 @@ export interface StatusReportPayload {
     defaultWorkspaceId?: string | null;
     defaultWorkspacePath?: string | null;
     workspaceActivity?: WorkspaceActivity[];
-    recentSessions?: RecentSessionEntry[];
+    recentLaunches?: RecentLaunchEntry[];
 }

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;
@@ -120,7 +124,6 @@ export interface SessionEntry {
     errorMessage?: string;
     errorReason?: _ProviderErrorReason;
     lastUpdated?: number;
-    recentKey?: string;
     unread?: boolean;
     lastSeenAt?: number;
     inboxBucket?: RecentSessionBucket;
@@ -215,22 +218,15 @@ export type { RecentSessionBucket, TerminalBackendStatus } from './shared-types-
 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;
 }
 
 // ─── Status Report Payload (daemon → server) ────────────────────────
@@ -259,7 +255,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/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,

package/src/status/reporter.ts

@@ -203,7 +203,7 @@ export class DaemonStatusReporter {
                 currentModel: session.currentModel,
                 currentPlan: session.currentPlan,
                 currentAutoApprove: session.currentAutoApprove,
-                recentKey: (session as any).recentKey,
+                lastUpdated: session.lastUpdated,
                 unread: (session as any).unread,
                 lastSeenAt: (session as any).lastSeenAt,
                 inboxBucket: (session as any).inboxBucket,

package/src/status/snapshot.ts

@@ -8,17 +8,18 @@
 
 import * as os from 'os';
 import { loadConfig } from '../config/config.js';
-import { buildRecentActivityKey, getRecentActivity, getRecentSessionSeenAt } from '../config/recent-activity.js';
+import { getRecentActivity, getSessionSeenAt, getSessionSeenMarker } from '../config/recent-activity.js';
 import { getWorkspaceState } from '../config/workspaces.js';
 import { getHostMemorySnapshot } from '../system/host-memory.js';
 import { getTerminalBackendRuntimeStatus } from '../cli-adapters/terminal-screen.js';
+import { LOG } from '../logging/logger.js';
 import { buildSessionEntries, isCdpConnected } from './builders.js';
 import type { ProviderState } from '../providers/provider-instance.js';
 import type {
     AvailableProviderInfo,
     DetectedIdeInfo,
+    RecentLaunchEntry,
     RecentSessionBucket,
-    RecentSessionEntry,
     SessionEntry,
     StatusReportPayload,
 } from '../shared-types.js';
@@ -53,6 +54,8 @@ export interface StatusSnapshot extends StatusReportPayload {
     availableProviders: AvailableProviderInfo[];
 }
 
+const READ_DEBUG_ENABLED = process.argv.includes('--dev') || process.env.ADHDEV_READ_DEBUG === '1';
+
 function buildDetectedIdeInfos(
     detectedIdes: StatusSnapshotOptions['detectedIdes'],
     cdpManagers: StatusSnapshotOptions['cdpManagers'],
@@ -104,6 +107,30 @@ function getSessionMessageUpdatedAt(session: {
     );
 }
 
+export 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
+}) {
+    const lastMessage = session.activeChat?.messages?.at?.(-1) as any;
+    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: {
     activeChat?: {
         messages?: Array<{ timestamp?: number | string; receivedAt?: number | string; createdAt?: number | string }> | null
@@ -113,7 +140,7 @@ function getSessionLastUsedAt(session: {
     return getSessionMessageUpdatedAt(session) || session.lastUpdated || Date.now();
 }
 
-function getSessionKind(session: SessionEntry): RecentSessionEntry['kind'] {
+function getSessionKind(session: SessionEntry): RecentLaunchEntry['kind'] {
     return session.transport === 'cdp-page' || session.transport === 'cdp-webview'
         ? 'ide'
         : session.transport === 'acp'
@@ -132,6 +159,8 @@ function getUnreadState(
     lastUsedAt: number,
     lastSeenAt: number,
     lastRole: string,
+    completionMarker: string,
+    seenCompletionMarker: string,
 ): { unread: boolean; inboxBucket: RecentSessionBucket } {
     if (status === 'waiting_approval') {
         return { unread: false, inboxBucket: 'needs_attention' };
@@ -139,88 +168,27 @@ function getUnreadState(
     if (status === 'generating' || status === 'starting') {
         return { unread: false, inboxBucket: 'working' };
     }
-    const unread = hasContentChange && lastUsedAt > lastSeenAt && lastRole !== 'user' && lastRole !== 'human';
+    const unread = completionMarker
+        ? completionMarker !== seenCompletionMarker
+        : hasContentChange && lastUsedAt > lastSeenAt && lastRole !== 'user' && lastRole !== 'human';
     return { unread, inboxBucket: unread ? 'task_complete' : 'idle' };
 }
 
-function buildRecentSessions(
-    sessions: ReturnType<typeof buildSessionEntries>,
+function buildRecentLaunches(
     recentActivity: ReturnType<typeof getRecentActivity>,
-    readState: Record<string, number>,
-): RecentSessionEntry[] {
-    const visibleKeys = new Set<string>();
-    const hiddenKeys = new Set<string>();
-    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' as RecentSessionBucket,
-                surfaceHidden: false,
-            };
-        });
-
-    return [...live, ...persisted]
-        .sort((a, b) => b.lastUsedAt - a.lastUsedAt)
+): RecentLaunchEntry[] {
+    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);
 }
 
@@ -233,16 +201,11 @@ export function buildStatusSnapshot(options: StatusSnapshotOptions): StatusSnaps
         options.allStates,
         options.cdpManagers as Map<string, any>,
     );
-    const readState = cfg.recentSessionReads || {};
     for (const session of sessions) {
-        const kind = getSessionKind(session);
-        const recentKey = buildRecentActivityKey({
-            kind,
-            providerType: session.providerType,
-            workspace: session.workspace,
-        });
-        const lastSeenAt = getRecentSessionSeenAt(cfg, recentKey);
+        const lastSeenAt = getSessionSeenAt(cfg, session.id);
+        const seenCompletionMarker = getSessionSeenMarker(cfg, session.id);
         const lastUsedAt = getSessionLastUsedAt(session);
+        const completionMarker = getSessionCompletionMarker(session);
         const { unread, inboxBucket } = session.surfaceHidden
             ? { unread: false, inboxBucket: 'idle' as RecentSessionBucket }
             : getUnreadState(
@@ -251,11 +214,18 @@ export function buildStatusSnapshot(options: StatusSnapshotOptions): StatusSnaps
                 lastUsedAt,
                 lastSeenAt,
                 getLastMessageRole(session),
+                completionMarker,
+                seenCompletionMarker,
             );
-        session.recentKey = recentKey;
         session.lastSeenAt = lastSeenAt;
         session.unread = unread;
         session.inboxBucket = inboxBucket;
+        if (READ_DEBUG_ENABLED && (session.unread || session.inboxBucket !== 'idle' || session.providerType.includes('codex'))) {
+            LOG.info(
+                'RecentRead',
+                `snapshot session id=${session.id} provider=${session.providerType} status=${String(session.status || '')} bucket=${inboxBucket} unread=${String(unread)} lastSeenAt=${lastSeenAt} completionMarker=${completionMarker || '-'} seenMarker=${seenCompletionMarker || '-'} lastUpdated=${String(session.lastUpdated || 0)} lastUsedAt=${lastUsedAt} lastRole=${getLastMessageRole(session)} msgUpdatedAt=${getSessionMessageUpdatedAt(session)}`,
+            );
+        }
     }
     const terminalBackend = getTerminalBackendRuntimeStatus();
 
@@ -283,7 +253,7 @@ export function buildStatusSnapshot(options: StatusSnapshotOptions): StatusSnaps
         workspaces: wsState.workspaces,
         defaultWorkspaceId: wsState.defaultWorkspaceId,
         defaultWorkspacePath: wsState.defaultWorkspacePath,
-        recentSessions: buildRecentSessions(sessions, recentActivity, readState),
+        recentLaunches: buildRecentLaunches(recentActivity),
         terminalBackend,
         availableProviders: buildAvailableProviders(options.providerLoader),
     };