@adhdev/daemon-core 0.7.35 → 0.7.36

package/src/config/recent-activity.ts

@@ -0,0 +1,83 @@
+/**
+ * Unified recent activity — machine-facing "pick up where you left off".
+ *
+ * Unlike cliHistory or workspaceActivity, this is task/session oriented:
+ * - one normalized row shape for IDE / CLI / ACP
+ * - deduped by kind + providerType + workspace
+ * - optionally linked to a live sessionId when known
+ */
+
+import * as path from 'path';
+import type { ADHDevConfig } from './config.js';
+import { expandPath } from './workspaces.js';
+
+export interface RecentActivityEntry {
+    id: string;
+    kind: 'ide' | 'cli' | 'acp';
+    providerType: string;
+    providerName: string;
+    workspace?: string | null;
+    currentModel?: string;
+    sessionId?: string | null;
+    title?: string;
+    lastUsedAt: number;
+}
+
+const MAX_ACTIVITY = 30;
+
+function normalizeWorkspace(workspace?: string | null) {
+    if (!workspace) return '';
+    try {
+        return path.resolve(expandPath(workspace));
+    } catch {
+        return path.resolve(workspace);
+    }
+}
+
+export function buildRecentActivityKey(entry: Pick<RecentActivityEntry, 'kind' | 'providerType' | 'workspace'>) {
+    return `${entry.kind}:${entry.providerType}:${normalizeWorkspace(entry.workspace)}`;
+}
+
+export function appendRecentActivity(
+    config: ADHDevConfig,
+    entry: Omit<RecentActivityEntry, 'id' | 'lastUsedAt'> & { lastUsedAt?: number },
+): ADHDevConfig {
+    const nextEntry: RecentActivityEntry = {
+        ...entry,
+        workspace: entry.workspace ? normalizeWorkspace(entry.workspace) : undefined,
+        id: buildRecentActivityKey(entry),
+        lastUsedAt: entry.lastUsedAt || Date.now(),
+    };
+
+    const filtered = (config.recentActivity || []).filter((item) => item.id !== nextEntry.id);
+    return {
+        ...config,
+        recentActivity: [nextEntry, ...filtered].slice(0, MAX_ACTIVITY),
+    };
+}
+
+export function getRecentActivity(config: ADHDevConfig, limit = 20): RecentActivityEntry[] {
+    return [...(config.recentActivity || [])]
+        .sort((a, b) => b.lastUsedAt - a.lastUsedAt)
+        .slice(0, limit);
+}
+
+export function getRecentSessionSeenAt(config: ADHDevConfig, recentKey: string): number {
+    return config.recentSessionReads?.[recentKey] || 0;
+}
+
+export function markRecentSessionSeen(
+    config: ADHDevConfig,
+    recentKey: string,
+    seenAt = Date.now(),
+): ADHDevConfig {
+    const prev = config.recentSessionReads || {};
+    const nextSeenAt = Math.max(prev[recentKey] || 0, seenAt);
+    return {
+        ...config,
+        recentSessionReads: {
+            ...prev,
+            [recentKey]: nextSeenAt,
+        },
+    };
+}

package/src/config/workspaces.d.ts

@@ -66,7 +66,9 @@ export declare function resolveIdeLaunchWorkspace(args: {
     useDefaultWorkspace?: boolean;
 } | undefined, config: ADHDevConfig): string | undefined;
 export declare function findWorkspaceByPath(config: ADHDevConfig, rawPath: string): WorkspaceEntry | undefined;
-export declare function addWorkspaceEntry(config: ADHDevConfig, rawPath: string, label?: string): {
+export declare function addWorkspaceEntry(config: ADHDevConfig, rawPath: string, label?: string, options?: {
+    createIfMissing?: boolean;
+}): {
     config: ADHDevConfig;
     entry: WorkspaceEntry;
 } | {

package/src/config/workspaces.ts

@@ -208,8 +208,22 @@ export function findWorkspaceByPath(config: ADHDevConfig, rawPath: string): Work
     return (config.workspaces || []).find(w => path.resolve(expandPath(w.path)) === abs);
 }
 
-export function addWorkspaceEntry(config: ADHDevConfig, rawPath: string, label?: string): { config: ADHDevConfig; entry: WorkspaceEntry } | { error: string } {
+export function addWorkspaceEntry(
+    config: ADHDevConfig,
+    rawPath: string,
+    label?: string,
+    options?: { createIfMissing?: boolean },
+): { config: ADHDevConfig; entry: WorkspaceEntry } | { error: string } {
     const abs = expandPath(rawPath);
+    const createIfMissing = options?.createIfMissing === true;
+    if (!abs) return { error: 'Path required' };
+    if (!fs.existsSync(abs) && createIfMissing) {
+        try {
+            fs.mkdirSync(abs, { recursive: true });
+        } catch (e: any) {
+            return { error: e?.message || 'Could not create directory' };
+        }
+    }
     const v = validateWorkspacePath(abs);
     if (!v.ok) return { error: v.error };
 

package/src/index.ts

@@ -28,6 +28,7 @@ export type {
   AvailableProviderInfo,
   AcpConfigOption,
   AcpMode,
+  ProviderControlSchema,
   StatusReportPayload,
   MachineInfo,
   DetectedIdeInfo,
@@ -42,6 +43,19 @@ 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;
+}
+
 // ── Core Interface ──
 export type { IDaemonCore, DaemonCoreOptions } from './daemon-core.js';
 
@@ -49,6 +63,8 @@ export type { IDaemonCore, DaemonCoreOptions } from './daemon-core.js';
 export { loadConfig, saveConfig, resetConfig, isSetupComplete, addCliHistory, 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';
 
 // ── Detection ──
 export { detectIDEs } from './detection/ide-detector.js';

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

@@ -228,6 +228,11 @@ export class AcpProviderInstance implements ProviderInstance {
  // Error details for dashboard display
             errorMessage: this.errorMessage || undefined,
             errorReason: this.errorReason || undefined,
+            controlValues: {
+                ...(this.currentModel ? { model: this.currentModel } : {}),
+                ...(this.currentMode ? { mode: this.currentMode } : {}),
+            },
+            providerControls: this.provider.controls as any,
         };
     }
 

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

@@ -126,6 +126,8 @@ export class CliProviderInstance implements ProviderInstance {
                 attachedClients: runtime.attachedClients || [],
             } : undefined,
             resume: this.provider.resume,
+            controlValues: undefined, // CLI controls not yet wired from stream
+            providerControls: this.provider.controls as any,
         };
     }
 

package/src/providers/contracts.ts

@@ -373,6 +373,10 @@ export interface ProviderModule {
  // ─── Provider Settings (variables controllable from dashboard) ───
   settings?: Record<string, ProviderSettingDef>;
 
+ // ─── Provider Controls (interactive controls exposed in chat UI) ───
+ /** Dynamic controls declared by provider — rendered in chat panel bar/header */
+  controls?: ProviderControlDef[];
+
  // ─── ACP Static Config (for agents without config/* support) ───
  /** Static options used when agent does not provide configOptions */
   staticConfigOptions?: Array<{
@@ -515,3 +519,93 @@ export interface ProviderSettingDef {
 export interface ProviderSettingSchema extends ProviderSettingDef {
   key: string;
 }
+
+// ─── Provider Controls (interactive chat-level controls) ────────
+
+/**
+ * Control types:
+ * - 'select'  — dropdown list (model picker, mode picker)
+ * - 'toggle'  — on/off switch (compact mode, auto-approve)
+ * - 'cycle'   — click-to-cycle through options (thinking level: low→med→high)
+ * - 'slider'  — numeric range (temperature: 0–2)
+ * - 'action'  — one-shot button (show usage, restart, clear context)
+ */
+export type ProviderControlType = 'select' | 'toggle' | 'cycle' | 'slider' | 'action';
+
+/**
+ * Where the control appears in the chat UI:
+ * - 'bar'    — thin strip below/above the chat input (always visible)
+ * - 'header' — in the agent header area
+ * - 'menu'   — inside a ⋯ overflow menu
+ */
+export type ProviderControlPlacement = 'bar' | 'header' | 'menu';
+
+/** Static option for select/cycle controls */
+export interface ProviderControlOption {
+  value: string;
+  label: string;
+  description?: string;
+  group?: string;
+}
+
+/**
+ * ProviderControlDef — A single interactive control declared by a provider.
+ *
+ * Controls are different from Settings:
+ * - Settings: background config, infrequently changed, managed in settings page
+ * - Controls: interactive, changed during chat, rendered inside chat panel
+ *
+ * Each control maps to provider scripts for get/set operations.
+ * The frontend renders controls automatically based on this schema —
+ * no hardcoded model/mode assumptions needed.
+ *
+ * For 'action' type:
+ * - Renders as a button. On click → calls invokeScript.
+ * - No value state. Optionally shows result via toast/inline.
+ */
+export interface ProviderControlDef {
+ /** Unique identifier (e.g. 'model', 'mode', 'thinking', 'usage') */
+  id: string;
+ /** Control type */
+  type: ProviderControlType;
+ /** Display label */
+  label: string;
+ /** Icon (emoji or icon name) */
+  icon?: string;
+ /** Where to show this control in the UI */
+  placement: ProviderControlPlacement;
+
+ // ─── Options (for select/cycle) ───
+ /** Static options — used when the list is known at definition time */
+  options?: ProviderControlOption[];
+ /** Dynamic options — load via script at runtime */
+  dynamic?: boolean;
+ /** Script name to list options (e.g. 'listModels') — required when dynamic=true */
+  listScript?: string;
+
+ // ─── Value (for select/toggle/cycle/slider) ───
+ /** Script name to change value (e.g. 'setModel') — required for value-based controls */
+  setScript?: string;
+ /** Field name in readChat() result to read current value (e.g. 'model', 'mode') */
+  readFrom?: string;
+ /** Default value */
+  defaultValue?: string | number | boolean;
+
+ // ─── Action (for 'action' type) ───
+ /** Script name to invoke (one-shot call, no value) */
+  invokeScript?: string;
+ /** How to display action result: 'toast' = notification, 'inline' = show in bar, 'none' = silent */
+  resultDisplay?: 'toast' | 'inline' | 'none';
+
+ // ─── Slider-specific ───
+  min?: number;
+  max?: number;
+  step?: number;
+
+ // ─── Display ───
+ /** Sort order within placement group (lower = first) */
+  order?: number;
+ /** Hide this control when condition not met */
+  hidden?: boolean;
+}
+

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

@@ -25,6 +25,7 @@ export class ExtensionProviderInstance implements ProviderInstance {
     private activeModal: any = null;
     private currentModel: string = '';
     private currentMode: string = '';
+    private controlValues: Record<string, string | number | boolean> = {};
     private lastAgentStatus: string = 'idle';
     private generatingStartedAt: number = 0;
     private monitor: StatusMonitor;
@@ -82,6 +83,8 @@ export class ExtensionProviderInstance implements ProviderInstance {
             } : null,
             currentModel: this.currentModel || undefined,
             currentPlan: this.currentMode || undefined,
+            controlValues: this.controlValues,
+            providerControls: this.provider.controls as any,
             agentStreams: this.agentStreams,
             instanceId: this.instanceId,
             lastUpdated: Date.now(),
@@ -98,6 +101,7 @@ export class ExtensionProviderInstance implements ProviderInstance {
             if (data?.activeModal !== undefined) this.activeModal = data.activeModal;
             if (data?.model) this.currentModel = data.model;
             if (data?.mode) this.currentMode = data.mode;
+            if (data?.controlValues) this.controlValues = data.controlValues;
             if (typeof data?.sessionId === 'string' && data.sessionId.trim()) this.chatId = data.sessionId;
             if (typeof data?.title === 'string' && data.title.trim()) this.chatTitle = data.title;
             if (typeof data?.agentName === 'string' && data.agentName.trim()) this.agentName = data.agentName;

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

@@ -125,6 +125,8 @@ export class IdeProviderInstance implements ProviderInstance {
             currentModel: this.cachedChat?.model || undefined,
             currentPlan: this.cachedChat?.mode || undefined,
             currentAutoApprove: this.cachedChat?.autoApprove || undefined,
+            controlValues: this.cachedChat?.controlValues || undefined,
+            providerControls: this.provider.controls as any,
             instanceId: this.instanceId,
             lastUpdated: Date.now(),
             settings: this.settings,

package/src/providers/provider-instance.ts

@@ -9,7 +9,7 @@
  */
 
 import type { ProviderModule, ProviderSettingDef, ProviderResumeCapability } from './contracts.js';
-import type { AcpConfigOption, AcpMode } from '../shared-types.js';
+import type { AcpConfigOption, AcpMode, ProviderControlSchema } from '../shared-types.js';
 import type { ChatMessage } from '../types.js';
 
 // ─── ProviderState — Discriminated union by category ─────────────
@@ -83,6 +83,10 @@ interface ProviderStateBase {
     pendingEvents: ProviderEvent[];
     runtime?: ProviderRuntimeInfo;
     resume?: ProviderResumeCapability;
+ /** Dynamic control current values */
+    controlValues?: Record<string, string | number | boolean>;
+ /** Provider-declared controls schema (from provider.controls) */
+    providerControls?: ProviderControlSchema[];
 }
 
 /** IDE provider state */

package/src/shared-types.d.ts

@@ -67,6 +67,8 @@ export interface SessionEntry {
     currentAutoApprove?: string;
     acpConfigOptions?: AcpConfigOption[];
     acpModes?: AcpMode[];
+    controlValues?: Record<string, string | number | boolean>;
+    providerControls?: ProviderControlSchema[];
     errorMessage?: string;
     errorReason?: _ProviderErrorReason;
 }
@@ -96,6 +98,26 @@ export interface AcpMode {
     name: string;
     description?: string;
 }
+/** Provider control schema (daemon → frontend) */
+export interface ProviderControlSchema {
+    id: string;
+    type: 'select' | 'toggle' | 'cycle' | 'slider' | 'action';
+    label: string;
+    icon?: string;
+    placement: 'bar' | 'header' | 'menu';
+    options?: { value: string; label: string; description?: string; group?: string }[];
+    dynamic?: boolean;
+    listScript?: string;
+    setScript?: string;
+    readFrom?: string;
+    defaultValue?: string | number | boolean;
+    invokeScript?: string;
+    resultDisplay?: 'toast' | 'inline' | 'none';
+    min?: number;
+    max?: number;
+    step?: number;
+    order?: number;
+}
 /** Machine hardware/OS info (reported by daemon, displayed by web) */
 export interface MachineInfo {
     hostname: string;
@@ -125,6 +147,18 @@ export interface WorkspaceActivity {
     kind?: string;
     agentType?: string;
 }
+export interface RecentSessionEntry {
+    id: string;
+    sessionId?: string | null;
+    providerType: string;
+    providerName: string;
+    kind: 'ide' | 'cli' | 'acp';
+    title: string;
+    workspace?: string | null;
+    currentModel?: string;
+    status?: SessionEntry['status'];
+    lastUsedAt: number;
+}
 export interface StatusReportPayload {
     /** Daemon instance ID */
     instanceId: string;
@@ -154,4 +188,5 @@ export interface StatusReportPayload {
     defaultWorkspaceId?: string | null;
     defaultWorkspacePath?: string | null;
     workspaceActivity?: WorkspaceActivity[];
+    recentSessions?: RecentSessionEntry[];
 }

package/src/shared-types.ts

@@ -117,8 +117,17 @@ export interface SessionEntry {
     currentAutoApprove?: string;
     acpConfigOptions?: AcpConfigOption[];
     acpModes?: AcpMode[];
+    /** Dynamic control current values (generic key-value) */
+    controlValues?: Record<string, string | number | boolean>;
+    /** Provider-declared controls schema (transmitted once, cached by frontend) */
+    providerControls?: ProviderControlSchema[];
     errorMessage?: string;
     errorReason?: _ProviderErrorReason;
+    lastUpdated?: number;
+    recentKey?: string;
+    unread?: boolean;
+    lastSeenAt?: number;
+    inboxBucket?: RecentSessionBucket;
 }
 
 /** Available provider information */
@@ -145,6 +154,40 @@ export interface AcpMode {
     description?: string;
 }
 
+// ─── Provider Controls Schema (daemon → frontend) ──────────────────
+// Serializable subset of ProviderControlDef — used for dynamic UI rendering
+
+/** Provider control schema transmitted to frontend */
+export interface ProviderControlSchema {
+    id: string;
+    type: 'select' | 'toggle' | 'cycle' | 'slider' | 'action';
+    label: string;
+    icon?: string;
+    placement: 'bar' | 'header' | 'menu';
+    /** Static options (for select/cycle) */
+    options?: { value: string; label: string; description?: string; group?: string }[];
+    /** Dynamic options — frontend should call listScript to load */
+    dynamic?: boolean;
+    /** Script name to list options */
+    listScript?: string;
+    /** Script name to change value (value-based controls) */
+    setScript?: string;
+    /** Field name in readChat result for current value */
+    readFrom?: string;
+    /** Default value */
+    defaultValue?: string | number | boolean;
+    /** Script name to invoke (action type) */
+    invokeScript?: string;
+    /** How to display action result */
+    resultDisplay?: 'toast' | 'inline' | 'none';
+    /** Slider range */
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Sort order */
+    order?: number;
+}
+
 // ─── Common Sub-Types (used across StatusReportPayload, BaseDaemonData, etc.) ──
 
 /** Machine hardware/OS info (reported by daemon, displayed by web) */
@@ -179,6 +222,31 @@ export interface WorkspaceActivity {
     agentType?: string;
 }
 
+export interface RecentSessionEntry {
+    id: string;
+    recentKey: string;
+    sessionId?: string | null;
+    providerType: string;
+    providerName: string;
+    kind: 'ide' | 'cli' | 'acp';
+    title: string;
+    workspace?: string | null;
+    currentModel?: string;
+    status?: SessionEntry['status'];
+    lastUsedAt: number;
+    unread?: boolean;
+    lastSeenAt?: number;
+    inboxBucket?: RecentSessionBucket;
+}
+
+export type RecentSessionBucket = 'needs_attention' | 'working' | 'task_complete' | 'idle';
+
+export interface TerminalBackendStatus {
+    backend: 'xterm' | 'ghostty-vt';
+    preference: 'auto' | 'xterm' | 'ghostty-vt';
+    ghosttyAvailable: boolean;
+}
+
 // ─── Status Report Payload (daemon → server) ────────────────────────
 // Full payload shape sent via WebSocket status_report
 
@@ -206,4 +274,6 @@ export interface StatusReportPayload {
     defaultWorkspaceId?: string | null;
     defaultWorkspacePath?: string | null;
     workspaceActivity?: WorkspaceActivity[];
+    recentSessions?: RecentSessionEntry[];
+    terminalBackend?: TerminalBackendStatus;
 }

package/src/status/builders.ts

@@ -9,7 +9,7 @@
  */
 
 import type { DaemonCdpManager } from '../cdp/manager.js';
-import type { SessionEntry, SessionCapability } from '../shared-types.js';
+import type { SessionEntry, SessionCapability, ProviderControlSchema, AcpConfigOption, AcpMode } from '../shared-types.js';
 import type {
     IdeProviderState,
     CliProviderState,
@@ -75,6 +75,67 @@ export function isCdpConnected(
     return m?.isConnected ?? false;
 }
 
+/**
+ * Build legacy controls for providers that haven't been updated to the new schema.
+ * Replaces the frontend fallback logic.
+ */
+function buildFallbackControls(
+    providerControls?: ProviderControlSchema[],
+    serverModel?: string,
+    serverMode?: string,
+    acpConfigOptions?: AcpConfigOption[],
+    acpModes?: AcpMode[],
+): ProviderControlSchema[] {
+    if (providerControls && providerControls.length > 0) return providerControls;
+    const controls: ProviderControlSchema[] = [];
+
+    const isAcp = !!(acpConfigOptions || acpModes);
+
+    // Legacy model control
+    const modelFromAcp = acpConfigOptions?.find(c => c.category === 'model');
+    if (!isAcp || modelFromAcp) {
+        controls.push({
+            id: 'model',
+            type: 'select',
+            label: 'Model',
+            icon: '🤖',
+            placement: 'bar',
+            dynamic: !modelFromAcp,
+            listScript: 'listModels',
+            setScript: 'setModel',
+            readFrom: 'model',
+            ...(modelFromAcp && {
+                options: modelFromAcp.options.map((o: any) => ({ value: o.value, label: o.name || o.value })),
+            }),
+        });
+    }
+
+    // Legacy mode control
+    const modeFromAcp = acpModes && acpModes.length > 0;
+    const thoughtFromAcp = !modeFromAcp && acpConfigOptions?.find((c: any) => c.category !== 'model');
+    if (!isAcp || modeFromAcp || thoughtFromAcp) {
+        controls.push({
+            id: 'mode',
+            type: thoughtFromAcp ? 'cycle' : 'select',
+            label: thoughtFromAcp ? 'Thinking' : 'Mode',
+            icon: thoughtFromAcp ? '🧠' : '⚡',
+            placement: 'bar',
+            dynamic: !modeFromAcp && !thoughtFromAcp,
+            listScript: 'listModes',
+            setScript: thoughtFromAcp ? 'setThinkingLevel' : 'setMode',
+            readFrom: 'mode',
+            ...(modeFromAcp && {
+                options: acpModes!.map((m: any) => ({ value: m.id, label: m.name || m.id })),
+            }),
+            ...(thoughtFromAcp && {
+                options: thoughtFromAcp.options.map((o: any) => ({ value: o.value, label: o.name || o.value })),
+            }),
+        });
+    }
+
+    return controls;
+}
+
 const IDE_SESSION_CAPABILITIES: SessionCapability[] = [
     'read_chat',
     'send_message',
@@ -140,8 +201,15 @@ function buildIdeWorkspaceSession(
         currentModel: state.currentModel,
         currentPlan: state.currentPlan,
         currentAutoApprove: state.currentAutoApprove,
+        controlValues: state.controlValues,
+        providerControls: buildFallbackControls(
+            state.providerControls,
+            state.currentModel,
+            state.currentPlan
+        ),
         errorMessage: state.errorMessage,
         errorReason: state.errorReason,
+        lastUpdated: state.lastUpdated,
     };
 }
 
@@ -166,8 +234,15 @@ function buildExtensionAgentSession(
         capabilities: EXTENSION_SESSION_CAPABILITIES,
         currentModel: ext.currentModel,
         currentPlan: ext.currentPlan,
+        controlValues: ext.controlValues,
+        providerControls: buildFallbackControls(
+            ext.providerControls,
+            ext.currentModel,
+            ext.currentPlan
+        ),
         errorMessage: ext.errorMessage,
         errorReason: ext.errorReason,
+        lastUpdated: ext.lastUpdated,
     };
 }
 
@@ -193,8 +268,13 @@ function buildCliSession(state: CliProviderState): SessionEntry {
         resume: state.resume,
         activeChat,
         capabilities: PTY_SESSION_CAPABILITIES,
+        controlValues: state.controlValues,
+        providerControls: buildFallbackControls(
+            state.providerControls
+        ),
         errorMessage: state.errorMessage,
         errorReason: state.errorReason,
+        lastUpdated: state.lastUpdated,
     };
 }
 
@@ -218,8 +298,17 @@ function buildAcpSession(state: AcpProviderState): SessionEntry {
         currentPlan: state.currentPlan,
         acpConfigOptions: state.acpConfigOptions,
         acpModes: state.acpModes,
+        controlValues: state.controlValues,
+        providerControls: buildFallbackControls(
+            state.providerControls,
+            state.currentModel,
+            state.currentPlan,
+            state.acpConfigOptions,
+            state.acpModes
+        ),
         errorMessage: state.errorMessage,
         errorReason: state.errorReason,
+        lastUpdated: state.lastUpdated,
     };
 }
 

package/src/status/reporter.ts

@@ -203,6 +203,14 @@ export class DaemonStatusReporter {
                 currentModel: session.currentModel,
                 currentPlan: session.currentPlan,
                 currentAutoApprove: session.currentAutoApprove,
+                recentKey: (session as any).recentKey,
+                unread: (session as any).unread,
+                lastSeenAt: (session as any).lastSeenAt,
+                inboxBucket: (session as any).inboxBucket,
+                controlValues: session.controlValues,
+                providerControls: session.providerControls,
+                acpConfigOptions: session.acpConfigOptions,
+                acpModes: session.acpModes,
             })),
             p2p: payload.p2p,
             timestamp: now,