@adhdev/daemon-core 0.7.38 → 0.7.40

package/src/commands/router.ts

@@ -18,14 +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 { appendWorkspaceActivity } from '../config/workspace-activity.js';
-import { addCliHistory } from '../config/config.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 ───
@@ -63,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;
@@ -208,17 +209,6 @@ export class DaemonCommandRouter {
                 };
                 LOG.info('LaunchIDE', `target=${ideKey || 'auto'}`);
                 const result = await launchWithCdp(launchArgs);
-                if (result.success && (result.ideId || ideKey)) {
-                    try {
-                        addCliHistory({
-                            category: 'ide',
-                            cliType: result.ideId || ideKey,
-                            dir: resolvedWorkspace || '',
-                            workspace: resolvedWorkspace || '',
-                            newWindow: args?.newWindow === true,
-                        });
-                    } catch { /* ignore history failure */ }
-                }
 
                 if (result.success && result.port && result.ideId && !this.deps.cdpManagers.has(result.ideId)) {
                     const logFn = this.deps.getCdpLogFn
@@ -241,11 +231,7 @@ export class DaemonCommandRouter {
                 this.deps.onIdeConnected?.();
                 if (result.success && resolvedWorkspace) {
                     try {
-                        let next = appendWorkspaceActivity(loadConfig(), resolvedWorkspace, {
-                            kind: 'ide',
-                            agentType: result.ideId,
-                        });
-                        next = appendRecentActivity(next, {
+                        const next = appendRecentActivity(loadConfig(), {
                             kind: 'ide',
                             providerType: result.ideId || ideKey,
                             providerName: result.ideId || ideKey,
@@ -282,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/commands/stream-commands.ts

@@ -5,7 +5,6 @@
 
 import type { CommandResult, CommandHelpers } from './handler.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
-import { loadConfig } from '../config/config.js';
 import { LOG } from '../logging/logger.js';
 
 export async function handleFocusSession(h: CommandHelpers, args: any): Promise<CommandResult> {
@@ -193,14 +192,13 @@ export function handleGetIdeExtensions(h: CommandHelpers, args: any): CommandRes
     if (!loader) return { success: false, error: 'ProviderLoader not initialized' };
 
     const allExtProviders = loader.getByCategory?.('extension') || [];
-    const config = loadConfig();
 
     if (ideType) {
         const extensions = allExtProviders.map(p => ({
             type: p.type,
             name: p.name,
             extensionId: p.extensionId,
-            enabled: config.ideSettings?.[ideType]?.extensions?.[p.type]?.enabled === true,
+            enabled: loader.getIdeExtensionEnabledState?.(ideType, p.type) === true,
         }));
         return { success: true, ideType, extensions };
     }
@@ -212,7 +210,7 @@ export function handleGetIdeExtensions(h: CommandHelpers, args: any): CommandRes
             type: p.type,
             name: p.name,
             extensionId: p.extensionId,
-            enabled: config.ideSettings?.[ide]?.extensions?.[p.type]?.enabled === true,
+            enabled: loader.getIdeExtensionEnabledState?.(ide, p.type) === true,
         }));
     }
     return { success: true, ideExtensions: result };

package/src/commands/workspace-commands.ts

@@ -4,7 +4,6 @@
 
 import { loadConfig, saveConfig } from '../config/config.js';
 import * as W from '../config/workspaces.js';
-import { appendWorkspaceActivity, getWorkspaceActivity, removeActivityForPath } from '../config/workspace-activity.js';
 
 export type WorkspaceCommandResult = { success: boolean;[key: string]: unknown };
 
@@ -16,8 +15,6 @@ export function handleWorkspaceList(): WorkspaceCommandResult {
         workspaces: state.workspaces,
         defaultWorkspaceId: state.defaultWorkspaceId,
         defaultWorkspacePath: state.defaultWorkspacePath,
-        legacyRecentPaths: config.recentCliWorkspaces || [],
-        activity: getWorkspaceActivity(config, 25),
     };
 }
 
@@ -31,10 +28,9 @@ export function handleWorkspaceAdd(args: any): WorkspaceCommandResult {
     const result = W.addWorkspaceEntry(config, rawPath, label, { createIfMissing });
     if ('error' in result) return { success: false, error: result.error };
 
-    let cfg = appendWorkspaceActivity(result.config, result.entry.path, {});
-    saveConfig(cfg);
-    const state = W.getWorkspaceState(cfg);
-    return { success: true, entry: result.entry, ...state, activity: getWorkspaceActivity(cfg, 25) };
+    saveConfig(result.config);
+    const state = W.getWorkspaceState(result.config);
+    return { success: true, entry: result.entry, ...state };
 }
 
 export function handleWorkspaceRemove(args: any): WorkspaceCommandResult {
@@ -46,13 +42,9 @@ export function handleWorkspaceRemove(args: any): WorkspaceCommandResult {
     const result = W.removeWorkspaceEntry(config, id);
     if ('error' in result) return { success: false, error: result.error };
 
-    let cfg = result.config;
-    if (removed) {
-        cfg = removeActivityForPath(cfg, removed.path);
-    }
-    saveConfig(cfg);
-    const state = W.getWorkspaceState(cfg);
-    return { success: true, removedId: id, ...state, activity: getWorkspaceActivity(cfg, 25) };
+    saveConfig(result.config);
+    const state = W.getWorkspaceState(result.config);
+    return { success: true, removedId: id, ...state };
 }
 
 export function handleWorkspaceSetDefault(args: any): WorkspaceCommandResult {
@@ -66,7 +58,6 @@ export function handleWorkspaceSetDefault(args: any): WorkspaceCommandResult {
         return {
             success: true,
             ...state,
-            activity: getWorkspaceActivity(result.config, 25),
         };
     }
 
@@ -98,12 +89,7 @@ export function handleWorkspaceSetDefault(args: any): WorkspaceCommandResult {
     const result = W.setDefaultWorkspaceId(config, nextId);
     if ('error' in result) return { success: false, error: result.error };
 
-    let out = result.config;
-    const ap = W.getDefaultWorkspacePath(out);
-    if (ap) {
-        out = appendWorkspaceActivity(out, ap, { kind: 'default' });
-    }
-    saveConfig(out);
-    const state = W.getWorkspaceState(out);
-    return { success: true, ...state, activity: getWorkspaceActivity(out, 25) };
+    saveConfig(result.config);
+    const state = W.getWorkspaceState(result.config);
+    return { success: true, ...state };
 }

package/src/config/config.ts

@@ -8,12 +8,9 @@ import { homedir } from 'os';
 import { join } from 'path';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync } from 'fs';
 import { randomUUID } from 'crypto';
-import { migrateWorkspacesFromRecent } from './workspaces.js';
 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 {
@@ -54,19 +51,18 @@ export interface ADHDevConfig {
 
  // Daemon: which IDEs to connect (empty = all)
     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 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;
@@ -94,9 +90,6 @@ export interface ADHDevConfig {
      */
     registeredMachineId?: string;
 
- // CLI launch history
-    cliHistory: CliHistoryEntry[];
-
  // Per-provider user config (public setting values)
     providerSettings: Record<string, Record<string, any>>;
 
@@ -113,18 +106,6 @@ export interface ADHDevConfig {
     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;
-}
-
 const DEFAULT_CONFIG: ADHDevConfig = {
     serverUrl: 'https://api.adhf.dev',
     apiToken: null,
@@ -140,17 +121,15 @@ const DEFAULT_CONFIG: ADHDevConfig = {
     setupDate: null,
     configuredCLIs: [],
     enabledIdes: [],
-    recentCliWorkspaces: [],
     workspaces: [],
     defaultWorkspaceId: null,
-    recentWorkspaceActivity: [],
     recentActivity: [],
-    recentSessionReads: {},
+    sessionReads: {},
+    sessionReadMarkers: {},
     machineNickname: null,
     machineId: undefined,
     machineSecret: null,
     registeredMachineId: undefined,
-    cliHistory: [],
     providerSettings: {},
     ideSettings: {},
     disableUpstream: false,
@@ -227,18 +206,9 @@ export function loadConfig(): ADHDevConfig {
             (merged as ADHDevConfig).defaultWorkspaceId = merged.activeWorkspaceId;
         }
         delete (merged as any).activeWorkspaceId;
-        const hadStoredWorkspaces = Array.isArray(parsed.workspaces) && parsed.workspaces.length > 0;
         const ensured = ensureMachineId(merged);
         const normalized = ensured.config as ADHDevConfig & { activeWorkspaceId?: string | null };
-        migrateWorkspacesFromRecent(normalized);
-        
-        let configChanged = ensured.changed;
-
-        if (!hadStoredWorkspaces && (normalized.workspaces?.length || 0) > 0) {
-            configChanged = true;
-        }
-
-        if (configChanged) {
+        if (ensured.changed) {
             try {
                 saveConfig(normalized);
             } catch { /* ignore */ }
@@ -318,47 +288,3 @@ export function generateConnectionToken(): string {
     }
     return token;
 }
-/**
- * Add launch to history (max 20, dedup by category+type+dir+args+workspace+model)
- */
-export function addCliHistory(entry: Omit<CliHistoryEntry, 'timestamp'>): void {
-    const config = loadConfig();
-    const history = config.cliHistory || [];
-    const argsKey = (entry.cliArgs || []).join(' ');
-    const category = entry.category || 'cli';
-    const workspaceKey = entry.workspace || '';
-    const modelKey = entry.model || '';
-    
- // Remove duplicate (same category + type + dir + args + workspace + model)
-    const filtered = history.filter(h => {
-        const hArgsKey = (h.cliArgs || []).join(' ');
-        return !(
-            (h.category || 'cli') === category &&
-            h.cliType === entry.cliType &&
-            h.dir === entry.dir &&
-            hArgsKey === argsKey &&
-            (h.workspace || '') === workspaceKey &&
-            (h.model || '') === modelKey
-        );
-    });
-    
- // Add to front
-    filtered.unshift({
-        ...entry,
-        category,
-        timestamp: Date.now(),
-        label: entry.label || (() => {
-            const base = `${entry.cliType} · ${entry.dir.split('/').filter(Boolean).pop() || 'root'}`;
-            const suffix: string[] = [];
-            if (entry.workspace && entry.workspace !== entry.dir) suffix.push(entry.workspace.split('/').filter(Boolean).pop() || entry.workspace);
-            if (entry.model) suffix.push(`model=${entry.model}`);
-            if (argsKey) suffix.push(argsKey);
-            if (entry.newWindow) suffix.push('new window');
-            return suffix.length > 0 ? `${base} (${suffix.join(' · ')})` : base;
-        })(),
-    });
-    
- // Keep max 20
-    config.cliHistory = filtered.slice(0, 20);
-    saveConfig(config);
-}

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/config/workspaces.ts

@@ -42,30 +42,6 @@ export function defaultWorkspaceLabel(absPath: string): string {
     return base;
 }
 
-/**
- * Ensure config.workspaces exists; seed from recentCliWorkspaces once (same paths).
- */
-export function migrateWorkspacesFromRecent(config: ADHDevConfig): ADHDevConfig {
-    if (!config.workspaces) config.workspaces = [];
-    if (config.workspaces.length > 0) return config;
-
-    const recent = config.recentCliWorkspaces || [];
-    const now = Date.now();
-    for (const raw of recent) {
-        const abs = expandPath(raw);
-        if (!abs || validateWorkspacePath(abs).ok !== true) continue;
-        if (config.workspaces.some(w => path.resolve(w.path) === abs)) continue;
-        config.workspaces.push({
-            id: randomUUID(),
-            path: abs,
-            label: defaultWorkspaceLabel(abs),
-            addedAt: now,
-        });
-        if (config.workspaces.length >= MAX_WORKSPACES) break;
-    }
-    return config;
-}
-
 export function getDefaultWorkspacePath(config: ADHDevConfig): string | null {
     const id = config.defaultWorkspaceId;
     if (!id) return null;

package/src/index.ts

@@ -33,7 +33,6 @@ export type {
   MachineInfo,
   DetectedIdeInfo,
   WorkspaceEntry,
-  WorkspaceActivity,
   ProviderStatus,
   ProviderErrorReason,
   ActiveChatData,
@@ -43,26 +42,28 @@ export type {
   ExtensionProviderState,
 } from './shared-types.js';
 
-export interface RecentSessionEntry {
-  id: string;
-  sessionId?: string | null;
-  providerType: string;
-  providerName: string;
-  kind: 'ide' | 'cli' | 'acp';
-  title: string;
-  workspace?: string | null;
-  currentModel?: string;
-  status?: 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
-  lastUsedAt: number;
-}
+// These types live in shared-types-extra.ts — imported directly because
+// 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 { 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 RecentLaunchEntry = _RecentLaunchEntry;
+export type TerminalBackendStatus = _TerminalBackendStatus;
+
+// Type aliases — rollup-dts cannot bundle re-exported type aliases at all.
+// Canonical definition lives in shared-types-extra.ts — keep these in sync.
+export type SessionStatus = 'idle' | 'generating' | 'waiting_approval' | 'error' | 'stopped' | 'starting' | 'panel_hidden' | 'not_monitored' | 'disconnected';
+export type RecentSessionBucket = 'needs_attention' | 'working' | 'task_complete' | 'idle';
 
 // ── Core Interface ──
 export type { IDaemonCore, DaemonCoreOptions } from './daemon-core.js';
 
 // ── Config ──
-export { loadConfig, saveConfig, resetConfig, isSetupComplete, addCliHistory, markSetupComplete, updateConfig } from './config/config.js';
+export { loadConfig, saveConfig, resetConfig, isSetupComplete, markSetupComplete, updateConfig } from './config/config.js';
 export { getWorkspaceState } from './config/workspaces.js';
-export { getWorkspaceActivity } from './config/workspace-activity.js';
 export { appendRecentActivity, getRecentActivity } from './config/recent-activity.js';
 export type { RecentActivityEntry } from './config/recent-activity.js';
 

package/src/providers/provider-loader.ts

@@ -284,16 +284,24 @@ export class ProviderLoader {
   isEnabled(type: string, ideType?: string): boolean {
     if (!ideType) return true;
     try {
-      const { loadConfig } = require('../config/config.js');
-      const config = loadConfig();
-      const baseIdeType = ideType.split('_')[0];
-      const val = config.ideSettings?.[baseIdeType]?.extensions?.[type]?.enabled;
-      return val === true; // undefined → false (default inactive)
+      return this.getIdeExtensionEnabledState(ideType, type);
     } catch {
       return false;
     }
   }
 
+ /**
+ * Resolve per-IDE extension enabled state using the same normalization
+ * that runtime attach/remove uses.
+ */
+  getIdeExtensionEnabledState(ideType: string, extensionType: string): boolean {
+    const { loadConfig } = require('../config/config.js');
+    const config = loadConfig();
+    const baseIdeType = ideType.split('_')[0];
+    const val = config.ideSettings?.[baseIdeType]?.extensions?.[extensionType]?.enabled;
+    return val === true;
+  }
+
  /**
  * Save IDE extension enabled setting
  */

package/src/shared-types-extra.ts

@@ -0,0 +1,34 @@
+/**
+ * ADHDev Shared Types — Additional cross-package type definitions
+ *
+ * Extracted common sub-types previously inlined across multiple packages.
+ * Separated from shared-types.ts due to rollup-dts bundling constraints.
+ *
+ * IMPORTANT: This file must remain runtime-free (types only).
+ */
+
+/** Runtime terminal write-owner descriptor */
+export interface RuntimeWriteOwner {
+    clientId: string;
+    ownerType: 'agent' | 'user';
+}
+
+/** Runtime attached client descriptor */
+export interface RuntimeAttachedClient {
+    clientId: string;
+    type: 'daemon' | 'web' | 'local-terminal';
+    readOnly: boolean;
+}
+
+/** 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';
+
+/** Terminal backend status */
+export interface TerminalBackendStatus {
+    backend: 'xterm' | 'ghostty-vt';
+    preference: 'auto' | 'xterm' | 'ghostty-vt';
+    ghosttyAvailable: boolean;
+}

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[];
 }