@adhdev/daemon-core 0.8.57 → 0.8.59

package/src/commands/router.ts

@@ -31,6 +31,7 @@ import { logCommand } from '../logging/command-log.js';
 import type { CommandLogEntry } from '../logging/command-log.js';
 import { getRecentLogs, LOG_PATH } from '../logging/logger.js';
 import { createInteractionId, getRecentDebugTrace, recordDebugTrace } from '../logging/debug-trace.js';
+import { getSessionHostSurfaceKind, partitionSessionHostRecords } from '../session-host/runtime-surface.js';
 import { buildSessionEntries } from '../status/builders.js';
 import { buildMachineInfo, buildStatusSnapshot } from '../status/snapshot.js';
 import { getSessionCompletionMarker } from '../status/snapshot.js';
@@ -137,6 +138,58 @@ function toHostedCliRuntimeDescriptor(record: any): HostedCliRuntimeDescriptor |
     };
 }
 
+function getWriteConflictOwnerClientId(error: unknown): string | undefined {
+    const message = typeof error === 'string'
+        ? error
+        : error instanceof Error
+            ? error.message
+            : '';
+    const match = /^Write owned by\s+(.+)$/.exec(message.trim());
+    return match?.[1]?.trim() || undefined;
+}
+
+function summarizeSessionHostRecord(result: unknown): Record<string, unknown> {
+    if (!result || typeof result !== 'object') return {};
+    const record = result as Record<string, any>;
+    return {
+        runtimeKey: typeof record.runtimeKey === 'string' ? record.runtimeKey : undefined,
+        lifecycle: typeof record.lifecycle === 'string' ? record.lifecycle : undefined,
+        surfaceKind: getSessionHostSurfaceKind(record as any),
+        attachedClientCount: Array.isArray(record.attachedClients) ? record.attachedClients.length : undefined,
+        hasWriteOwner: !!record.writeOwner,
+        writeOwnerClientId: typeof record.writeOwner?.clientId === 'string' ? record.writeOwner.clientId : undefined,
+    };
+}
+
+function summarizeSessionHostRecords(result: unknown): Record<string, unknown> {
+    const records = Array.isArray(result) ? result : [];
+    const groups = partitionSessionHostRecords(records as any[]);
+    return {
+        sessionCount: records.length,
+        liveRuntimeCount: groups.liveRuntimes.length,
+        recoverySnapshotCount: groups.recoverySnapshots.length,
+        inactiveRecordCount: groups.inactiveRecords.length,
+    };
+}
+
+function summarizeSessionHostDiagnostics(result: unknown): Record<string, unknown> {
+    const diagnostics = result && typeof result === 'object' ? result as Record<string, any> : {};
+    const sessions = Array.isArray(diagnostics.sessions) ? diagnostics.sessions : [];
+    return {
+        runtimeCount: typeof diagnostics.runtimeCount === 'number' ? diagnostics.runtimeCount : undefined,
+        ...summarizeSessionHostRecords(sessions),
+    };
+}
+
+function summarizeSessionHostPruneResult(result: unknown): Record<string, unknown> {
+    const value = result && typeof result === 'object' ? result as Record<string, any> : {};
+    return {
+        duplicateGroupCount: typeof value.duplicateGroupCount === 'number' ? value.duplicateGroupCount : undefined,
+        prunedCount: Array.isArray(value.prunedSessionIds) ? value.prunedSessionIds.length : undefined,
+        keptCount: Array.isArray(value.keptSessionIds) ? value.keptSessionIds.length : undefined,
+    };
+}
+
 export class DaemonCommandRouter {
     private deps: CommandRouterDeps;
 
@@ -144,6 +197,64 @@ export class DaemonCommandRouter {
         this.deps = deps;
     }
 
+    private async traceSessionHostAction<T>(
+        action: string,
+        args: any,
+        run: () => Promise<T>,
+        summarizeResult?: (result: T) => Record<string, unknown>,
+    ): Promise<T> {
+        const interactionId = typeof args?._interactionId === 'string' ? args._interactionId : undefined;
+        const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : undefined;
+        const requestedPayload: Record<string, unknown> = { action };
+        if (sessionId) requestedPayload.sessionId = sessionId;
+        if (typeof args?.clientId === 'string') requestedPayload.clientId = args.clientId;
+        if (typeof args?.signal === 'string') requestedPayload.signal = args.signal;
+        if (typeof args?.providerType === 'string') requestedPayload.providerType = args.providerType;
+        if (typeof args?.workspace === 'string') requestedPayload.workspace = args.workspace;
+        if (typeof args?.dryRun === 'boolean') requestedPayload.dryRun = args.dryRun;
+
+        recordDebugTrace({
+            interactionId,
+            category: 'session_host',
+            stage: 'action_requested',
+            level: 'info',
+            sessionId,
+            payload: requestedPayload,
+        });
+
+        try {
+            const result = await run();
+            recordDebugTrace({
+                interactionId,
+                category: 'session_host',
+                stage: 'action_result',
+                level: 'info',
+                sessionId,
+                payload: {
+                    ...requestedPayload,
+                    success: true,
+                    ...(summarizeResult ? summarizeResult(result) : {}),
+                },
+            });
+            return result;
+        } catch (error: any) {
+            recordDebugTrace({
+                interactionId,
+                category: 'session_host',
+                stage: 'action_failed',
+                level: 'error',
+                sessionId,
+                payload: {
+                    ...requestedPayload,
+                    error: error?.message || String(error),
+                    failureKind: getWriteConflictOwnerClientId(error) ? 'write_conflict' : 'request_failed',
+                    conflictOwnerClientId: getWriteConflictOwnerClientId(error),
+                },
+            });
+            throw error;
+        }
+    }
+
     /**
      * Unified command routing.
      * Returns result for all commands:
@@ -270,16 +381,20 @@ export class DaemonCommandRouter {
 
             case 'session_host_get_diagnostics': {
                 if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
-                const diagnostics = await this.deps.sessionHostControl.getDiagnostics({
+                const diagnostics = await this.traceSessionHostAction('session_host_get_diagnostics', args, () => this.deps.sessionHostControl!.getDiagnostics({
                     includeSessions: args?.includeSessions !== false,
                     limit: Number(args?.limit) || undefined,
-                });
+                }), (result) => ({
+                    includeSessions: args?.includeSessions !== false,
+                    limit: Number(args?.limit) || undefined,
+                    ...summarizeSessionHostDiagnostics(result),
+                }));
                 return { success: true, diagnostics };
             }
 
             case 'session_host_list_sessions': {
                 if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
-                const sessions = await this.deps.sessionHostControl.listSessions();
+                const sessions = await this.traceSessionHostAction('session_host_list_sessions', args, () => this.deps.sessionHostControl!.listSessions(), (records) => summarizeSessionHostRecords(records));
                 return { success: true, sessions };
             }
 
@@ -287,7 +402,7 @@ export class DaemonCommandRouter {
                 if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
                 const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
                 if (!sessionId) return { success: false, error: 'sessionId required' };
-                const record = await this.deps.sessionHostControl.stopSession(sessionId);
+                const record = await this.traceSessionHostAction('session_host_stop_session', args, () => this.deps.sessionHostControl!.stopSession(sessionId), (result) => summarizeSessionHostRecord(result));
                 return { success: true, record };
             }
 
@@ -295,11 +410,17 @@ export class DaemonCommandRouter {
                 if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
                 const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
                 if (!sessionId) return { success: false, error: 'sessionId required' };
-                const record = await this.deps.sessionHostControl.resumeSession(sessionId);
-                const hosted = toHostedCliRuntimeDescriptor(record);
-                if (hosted) {
-                    await this.deps.cliManager.restoreHostedSessions([hosted]);
-                }
+                const record = await this.traceSessionHostAction('session_host_resume_session', args, async () => {
+                    const nextRecord = await this.deps.sessionHostControl!.resumeSession(sessionId);
+                    const hosted = toHostedCliRuntimeDescriptor(nextRecord);
+                    if (hosted) {
+                        await this.deps.cliManager.restoreHostedSessions([hosted]);
+                    }
+                    return nextRecord;
+                }, (result) => ({
+                    ...summarizeSessionHostRecord(result),
+                    restoredHostedSession: !!toHostedCliRuntimeDescriptor(result),
+                }));
                 return { success: true, record };
             }
 
@@ -307,11 +428,17 @@ export class DaemonCommandRouter {
                 if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
                 const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';
                 if (!sessionId) return { success: false, error: 'sessionId required' };
-                const record = await this.deps.sessionHostControl.restartSession(sessionId);
-                const hosted = toHostedCliRuntimeDescriptor(record);
-                if (hosted) {
-                    await this.deps.cliManager.restoreHostedSessions([hosted]);
-                }
+                const record = await this.traceSessionHostAction('session_host_restart_session', args, async () => {
+                    const nextRecord = await this.deps.sessionHostControl!.restartSession(sessionId);
+                    const hosted = toHostedCliRuntimeDescriptor(nextRecord);
+                    if (hosted) {
+                        await this.deps.cliManager.restoreHostedSessions([hosted]);
+                    }
+                    return nextRecord;
+                }, (result) => ({
+                    ...summarizeSessionHostRecord(result),
+                    restoredHostedSession: !!toHostedCliRuntimeDescriptor(result),
+                }));
                 return { success: true, record };
             }
 
@@ -321,7 +448,7 @@ export class DaemonCommandRouter {
                 const signal = typeof args?.signal === 'string' ? args.signal : '';
                 if (!sessionId) return { success: false, error: 'sessionId required' };
                 if (!signal) return { success: false, error: 'signal required' };
-                const record = await this.deps.sessionHostControl.sendSignal(sessionId, signal);
+                const record = await this.traceSessionHostAction('session_host_send_signal', args, () => this.deps.sessionHostControl!.sendSignal(sessionId, signal), (result) => summarizeSessionHostRecord(result));
                 return { success: true, record };
             }
 
@@ -331,17 +458,17 @@ export class DaemonCommandRouter {
                 const clientId = typeof args?.clientId === 'string' ? args.clientId : '';
                 if (!sessionId) return { success: false, error: 'sessionId required' };
                 if (!clientId) return { success: false, error: 'clientId required' };
-                const record = await this.deps.sessionHostControl.forceDetachClient(sessionId, clientId);
+                const record = await this.traceSessionHostAction('session_host_force_detach_client', args, () => this.deps.sessionHostControl!.forceDetachClient(sessionId, clientId), (result) => summarizeSessionHostRecord(result));
                 return { success: true, record };
             }
 
             case 'session_host_prune_duplicate_sessions': {
                 if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
-                const result = await this.deps.sessionHostControl.pruneDuplicateSessions({
+                const result = await this.traceSessionHostAction('session_host_prune_duplicate_sessions', args, () => this.deps.sessionHostControl!.pruneDuplicateSessions({
                     providerType: typeof args?.providerType === 'string' ? args.providerType : undefined,
                     workspace: typeof args?.workspace === 'string' ? args.workspace : undefined,
                     dryRun: args?.dryRun === true,
-                });
+                }), (value) => summarizeSessionHostPruneResult(value));
                 return { success: true, result };
             }
 
@@ -352,12 +479,15 @@ export class DaemonCommandRouter {
                 const ownerType = args?.ownerType === 'agent' ? 'agent' : 'user';
                 if (!sessionId) return { success: false, error: 'sessionId required' };
                 if (!clientId) return { success: false, error: 'clientId required' };
-                const record = await this.deps.sessionHostControl.acquireWrite({
+                const record = await this.traceSessionHostAction('session_host_acquire_write', args, () => this.deps.sessionHostControl!.acquireWrite({
                     sessionId,
                     clientId,
                     ownerType,
                     force: args?.force !== false,
-                });
+                }), (result) => ({
+                    ...summarizeSessionHostRecord(result),
+                    ownerType,
+                }));
                 return { success: true, record };
             }
 
@@ -367,7 +497,10 @@ export class DaemonCommandRouter {
                 const clientId = typeof args?.clientId === 'string' ? args.clientId : '';
                 if (!sessionId) return { success: false, error: 'sessionId required' };
                 if (!clientId) return { success: false, error: 'clientId required' };
-                const record = await this.deps.sessionHostControl.releaseWrite({ sessionId, clientId });
+                const record = await this.traceSessionHostAction('session_host_release_write', args, () => this.deps.sessionHostControl!.releaseWrite({
+                    sessionId,
+                    clientId,
+                }), (result) => summarizeSessionHostRecord(result));
                 return { success: true, record };
             }
 
@@ -382,8 +515,9 @@ export class DaemonCommandRouter {
                     return { success: false, error: 'providerType required' };
                 }
 
-                const offset = Math.max(0, Number(args?.offset) || 0);
-                const limit = Math.max(1, Math.min(100, Number(args?.limit) || 30));
+                const wantsAll = args?.all === true;
+                const offset = wantsAll ? 0 : Math.max(0, Number(args?.offset) || 0);
+                const limit = wantsAll ? Number.MAX_SAFE_INTEGER : Math.max(1, Math.min(100, Number(args?.limit) || 30));
                 const { sessions: historySessions, hasMore } = listSavedHistorySessions(providerType, { offset, limit });
                 const state = loadState();
                 const savedSessions = getSavedProviderSessions(state, { providerType, kind });
@@ -406,13 +540,13 @@ export class DaemonCommandRouter {
                             providerName: saved?.providerName || recent?.providerName || providerType,
                             kind: saved?.kind || recent?.kind || kind,
                             title: saved?.title || recent?.title || session.sessionTitle || session.preview || providerType,
-                            workspace: saved?.workspace || recent?.workspace,
-                            currentModel: saved?.currentModel || recent?.currentModel,
+                            workspace: saved?.workspace || recent?.workspace || session.workspace,
+                            summaryMetadata: saved?.summaryMetadata || recent?.summaryMetadata,
                             preview: session.preview,
                             messageCount: session.messageCount,
                             firstMessageAt: session.firstMessageAt,
                             lastMessageAt: session.lastMessageAt,
-                            canResume: !!(saved?.workspace || recent?.workspace) && canResumeById,
+                            canResume: !!(saved?.workspace || recent?.workspace || session.workspace) && canResumeById,
                         };
                     }),
                     hasMore,

package/src/commands/stream-commands.ts

@@ -6,6 +6,8 @@
 import type { CommandResult, CommandHelpers } from './handler.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstance } from '../providers/provider-instance.js';
+import { loadConfig, saveConfig } from '../config/config.js';
+import { parseProviderSourceConfigUpdate } from '../config/provider-source-config.js';
 import { getCliScriptCommand, parseCliScriptResult } from '../providers/cli-script-results.js';
 import {
     normalizeControlInvokeResult,
@@ -107,10 +109,66 @@ export async function handleSetProviderSetting(h: CommandHelpers, args: any): Pr
     return { success: false, error: `Failed to set ${providerType}.${key} — invalid key, value, or not a public setting` };
 }
 
+export function handleGetProviderSourceConfig(h: CommandHelpers, _args: any): CommandResult {
+    const loader = h.ctx.providerLoader as ProviderLoader | undefined;
+    if (!loader) return { success: false, error: 'providerLoader not available' };
+    return { success: true, ...loader.getSourceConfig() };
+}
+
+export async function handleSetProviderSourceConfig(h: CommandHelpers, args: any): Promise<CommandResult> {
+    const loader = h.ctx.providerLoader as ProviderLoader | undefined;
+    if (!loader) return { success: false, error: 'providerLoader not available' };
+
+    const parsed = parseProviderSourceConfigUpdate(args || {});
+    if ('error' in parsed) {
+        return { success: false, error: parsed.error };
+    }
+
+    const currentConfig = loadConfig();
+    const nextConfig = {
+        ...currentConfig,
+        ...(parsed.updates.providerSourceMode ? { providerSourceMode: parsed.updates.providerSourceMode } : {}),
+        ...(Object.prototype.hasOwnProperty.call(parsed.updates, 'providerDir') ? { providerDir: parsed.updates.providerDir } : {}),
+    };
+    saveConfig(nextConfig);
+
+    const sourceConfig = loader.applySourceConfig({
+        sourceMode: nextConfig.providerSourceMode,
+        userDir: Object.prototype.hasOwnProperty.call(parsed.updates, 'providerDir') ? parsed.updates.providerDir : loader.getSourceConfig().explicitProviderDir || undefined,
+    });
+    loader.reload();
+    loader.registerToDetector();
+    await h.ctx.onProviderSourceConfigChanged?.();
+
+    LOG.info(
+        'Command',
+        `[set_provider_source_config] mode=${sourceConfig.sourceMode} explicitProviderDir=${sourceConfig.explicitProviderDir || '-'} userDir=${sourceConfig.userDir}`,
+    );
+
+    return { success: true, reloaded: true, ...sourceConfig };
+}
+
 // ─── Extension Script Execution (Model/Mode) ─────
 
-function normalizeProviderScriptArgs(args: any): Record<string, any> {
+export function normalizeProviderScriptArgs(args: any, scriptName?: string): Record<string, any> {
     const normalizedArgs = { ...(args || {}) };
+    const normalizedScriptName = String(scriptName || '').toLowerCase();
+
+    if (Object.prototype.hasOwnProperty.call(normalizedArgs, 'value')) {
+        if (
+            normalizedArgs.model === undefined
+            && (normalizedScriptName === 'setmodel' || normalizedScriptName === 'setmodelgui' || normalizedScriptName === 'webviewsetmodel')
+        ) {
+            normalizedArgs.model = normalizedArgs.value;
+        }
+        if (
+            normalizedArgs.mode === undefined
+            && (normalizedScriptName === 'setmode' || normalizedScriptName === 'webviewsetmode')
+        ) {
+            normalizedArgs.mode = normalizedArgs.value;
+        }
+    }
+
     for (const key of ['mode', 'model', 'message', 'action', 'button', 'text', 'sessionId', 'value']) {
         if (key in normalizedArgs && !(key.toUpperCase() in normalizedArgs)) {
             normalizedArgs[key.toUpperCase()] = normalizedArgs[key];
@@ -172,7 +230,7 @@ async function executeProviderScript(h: CommandHelpers, args: any, scriptName: s
         return { success: false, error: `Script '${actualScriptName}' not available for ${resolvedProviderType}` };
     }
 
-    const normalizedArgs = normalizeProviderScriptArgs(args);
+    const normalizedArgs = normalizeProviderScriptArgs(args, actualScriptName);
 
     if (provider.category === 'cli') {
         const adapter = h.getCliAdapter(args?.targetSessionId || resolvedProviderType);

package/src/config/chat-history.ts

@@ -27,6 +27,7 @@ interface HistoryMessage {
     instanceId?: string;  // IDE instance UUID (distinguishes windows of the same agent type)
     historySessionId?: string; // Persistent provider-side conversation/session key
     sessionTitle?: string;
+    workspace?: string;   // Working directory at session start (kind: 'session_start' only)
 }
 
 const CODEX_STARTER_PROMPT_RE = /^(?:[›❯]\s*)?(?:Find and fix a bug in @filename|Improve documentation in @filename|Write tests for @filename|Explain this codebase|Summarize recent commits|Implement \{feature\}|Use \/skills(?: to list available skills)?|Run \/review on my current changes)$/i;
@@ -123,6 +124,7 @@ export interface SavedHistorySessionSummary {
     firstMessageAt: number;
     lastMessageAt: number;
     preview?: string;
+    workspace?: string;
 }
 
 export class ChatHistoryWriter {
@@ -325,6 +327,37 @@ export class ChatHistoryWriter {
         );
     }
 
+    writeSessionStart(
+        agentType: string,
+        historySessionId: string,
+        workspace: string,
+        instanceId?: string,
+    ): void {
+        const id = String(historySessionId || '').trim();
+        const ws = String(workspace || '').trim();
+        if (!id || !ws) return;
+        try {
+            const dir = path.join(HISTORY_DIR, this.sanitize(agentType));
+            fs.mkdirSync(dir, { recursive: true });
+            const date = new Date().toISOString().slice(0, 10);
+            const filePath = path.join(dir, `${this.sanitize(id)}_${date}.jsonl`);
+            const record: HistoryMessage = {
+                ts: new Date().toISOString(),
+                receivedAt: Date.now(),
+                role: 'system',
+                kind: 'session_start',
+                content: ws,
+                agent: agentType,
+                instanceId,
+                historySessionId: id,
+                workspace: ws,
+            };
+            fs.appendFileSync(filePath, JSON.stringify(record) + '\n', 'utf-8');
+        } catch {
+            // Ignore — must not affect main functionality
+        }
+    }
+
     promoteHistorySession(
         agentType: string,
         previousHistorySessionId: string,
@@ -606,6 +639,7 @@ export function listSavedHistorySessions(
             let lastMessageAt = 0;
             let sessionTitle = '';
             let preview = '';
+            let workspace = '';
 
             for (const file of files.sort()) {
                 const filePath = path.join(dir, file);
@@ -619,6 +653,10 @@ export function listSavedHistorySessions(
                         parsed = null;
                     }
                     if (!parsed || parsed.historySessionId !== historySessionId) continue;
+                    if (parsed.kind === 'session_start') {
+                        if (!workspace && parsed.workspace) workspace = parsed.workspace;
+                        continue;
+                    }
                     messageCount += 1;
                     if (!firstMessageAt || parsed.receivedAt < firstMessageAt) firstMessageAt = parsed.receivedAt;
                     if (!lastMessageAt || parsed.receivedAt > lastMessageAt) lastMessageAt = parsed.receivedAt;
@@ -635,6 +673,7 @@ export function listSavedHistorySessions(
                 firstMessageAt,
                 lastMessageAt,
                 preview: preview || undefined,
+                workspace: workspace || undefined,
             });
         }
 

package/src/config/config.d.ts

@@ -8,6 +8,8 @@ export type { WorkspaceEntry } from './workspaces.js';
 export type { RecentActivityEntry } from './recent-activity.js';
 export type { SavedProviderSessionEntry } from './saved-sessions.js';
 export type { DaemonState } from './state-store.js';
+export type ProviderSourceMode = 'normal' | 'no-upstream';
+export declare function resolveProviderSourceMode(providerSourceMode: unknown, legacyDisableUpstream: unknown): ProviderSourceMode;
 export interface ADHDevConfig {
     serverUrl: string;
     selectedIde: string | null;
@@ -45,6 +47,7 @@ export interface ADHDevConfig {
         }>;
     }>;
     disableUpstream?: boolean;
+    providerSourceMode?: ProviderSourceMode;
     providerDir?: string;
     /**
      * Browser terminal sizing behavior for dashboard CLI panes.

package/src/config/config.ts

@@ -14,6 +14,18 @@ export type { RecentActivityEntry } from './recent-activity.js';
 export type { SavedProviderSessionEntry } from './saved-sessions.js';
 export type { DaemonState } from './state-store.js';
 
+export type ProviderSourceMode = 'normal' | 'no-upstream';
+
+export function resolveProviderSourceMode(
+    providerSourceMode: unknown,
+    legacyDisableUpstream: unknown,
+): ProviderSourceMode {
+    if (providerSourceMode === 'normal' || providerSourceMode === 'no-upstream') {
+        return providerSourceMode;
+    }
+    return legacyDisableUpstream === true ? 'no-upstream' : 'normal';
+}
+
 export interface ADHDevConfig {
  // Server connection
     serverUrl: string;
@@ -81,9 +93,13 @@ export interface ADHDevConfig {
 
  // Disable upstream provider auto-download (use builtin only)
  // Controllable from CLI (--no-upstream) and dashboard (machine page)
+ // Deprecated legacy boolean; prefer providerSourceMode.
     disableUpstream?: boolean;
 
- // Optional custom provider directory for local development
+ // Explicit machine-level provider source policy.
+    providerSourceMode?: ProviderSourceMode;
+
+ // Optional explicit provider override root (for example a local adhdev-providers checkout)
     providerDir?: string;
 
     /**
@@ -113,7 +129,7 @@ const DEFAULT_CONFIG: ADHDevConfig = {
     registeredMachineId: undefined,
     providerSettings: {},
     ideSettings: {},
-    disableUpstream: false,
+    providerSourceMode: 'normal',
     terminalSizingMode: 'measured',
 };
 
@@ -164,7 +180,7 @@ function normalizeConfig(raw: unknown): ADHDevConfig & { activeWorkspaceId?: str
         registeredMachineId: asOptionalString(parsed.registeredMachineId),
         providerSettings: isPlainObject(parsed.providerSettings) ? parsed.providerSettings : {},
         ideSettings: isPlainObject(parsed.ideSettings) ? parsed.ideSettings : {},
-        disableUpstream: asBoolean(parsed.disableUpstream, DEFAULT_CONFIG.disableUpstream ?? false),
+        providerSourceMode: resolveProviderSourceMode(parsed.providerSourceMode, parsed.disableUpstream),
         providerDir: asOptionalString(parsed.providerDir),
         terminalSizingMode: parsed.terminalSizingMode === 'fit' ? 'fit' : 'measured',
     };

package/src/config/provider-source-config.ts

@@ -0,0 +1,42 @@
+import type { ProviderSourceMode } from './config.js'
+
+export interface ProviderSourceConfigSnapshot {
+  sourceMode: ProviderSourceMode
+  disableUpstream: boolean
+  explicitProviderDir: string | null
+  userDir: string
+  upstreamDir: string
+  providerRoots: string[]
+}
+
+export interface ProviderSourceConfigUpdate {
+  providerSourceMode?: ProviderSourceMode
+  providerDir?: string | undefined
+}
+
+function normalizeProviderDir(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined
+  const trimmed = value.trim()
+  return trimmed ? trimmed : undefined
+}
+
+export function parseProviderSourceConfigUpdate(input: {
+  providerSourceMode?: unknown
+  providerDir?: unknown
+}): { ok: true; updates: ProviderSourceConfigUpdate } | { ok: false; error: string } {
+  const updates: ProviderSourceConfigUpdate = {}
+
+  if (Object.prototype.hasOwnProperty.call(input, 'providerSourceMode')) {
+    const { providerSourceMode } = input
+    if (providerSourceMode !== 'normal' && providerSourceMode !== 'no-upstream') {
+      return { ok: false, error: "providerSourceMode must be 'normal' or 'no-upstream'" }
+    }
+    updates.providerSourceMode = providerSourceMode
+  }
+
+  if (Object.prototype.hasOwnProperty.call(input, 'providerDir')) {
+    updates.providerDir = normalizeProviderDir(input.providerDir)
+  }
+
+  return { ok: true, updates }
+}

package/src/config/recent-activity.d.ts

@@ -6,6 +6,7 @@
  * - deduped by provider session when available, else by kind + providerType + workspace
  * - used only for quick-launch shortcuts
  */
+import type { ProviderSummaryMetadata } from '../shared-types.js';
 import type { DaemonState } from './state-store.js';
 export interface RecentActivityEntry {
     id: string;
@@ -14,7 +15,7 @@ export interface RecentActivityEntry {
     providerName: string;
     providerSessionId?: string;
     workspace?: string | null;
-    currentModel?: string;
+    summaryMetadata?: ProviderSummaryMetadata;
     title?: string;
     lastUsedAt: number;
 }

package/src/config/recent-activity.ts

@@ -8,8 +8,10 @@
  */
 
 import * as path from 'path';
+import type { ProviderSummaryMetadata } from '../shared-types.js';
 import type { DaemonState } from './state-store.js';
 import { expandPath } from './workspaces.js';
+import { normalizePersistedSummaryMetadata } from '../providers/summary-metadata.js';
 
 export interface RecentActivityEntry {
     id: string;
@@ -18,7 +20,7 @@ export interface RecentActivityEntry {
     providerName: string;
     providerSessionId?: string;
     workspace?: string | null;
-    currentModel?: string;
+    summaryMetadata?: ProviderSummaryMetadata;
     title?: string;
     lastUsedAt: number;
 }
@@ -55,6 +57,9 @@ export function appendRecentActivity(
     const nextEntry: RecentActivityEntry = {
         ...entry,
         workspace: entry.workspace ? normalizeWorkspace(entry.workspace) : undefined,
+        summaryMetadata: normalizePersistedSummaryMetadata({
+            summaryMetadata: entry.summaryMetadata,
+        }),
         id: buildRecentActivityKeyForEntry(entry),
         lastUsedAt: entry.lastUsedAt || Date.now(),
     };
@@ -68,6 +73,12 @@ export function appendRecentActivity(
 
 export function getRecentActivity(state: DaemonState, limit = 20): RecentActivityEntry[] {
     return [...(state.recentActivity || [])]
+        .map(entry => ({
+            ...entry,
+            summaryMetadata: normalizePersistedSummaryMetadata({
+                summaryMetadata: entry.summaryMetadata,
+            }),
+        }))
         .sort((a, b) => b.lastUsedAt - a.lastUsedAt)
         .slice(0, limit);
 }

package/src/config/saved-sessions.d.ts

@@ -1,3 +1,4 @@
+import type { ProviderSummaryMetadata } from '../shared-types.js';
 import type { DaemonState } from './state-store.js';
 export interface SavedProviderSessionEntry {
     id: string;
@@ -6,7 +7,7 @@ export interface SavedProviderSessionEntry {
     providerName: string;
     providerSessionId: string;
     workspace?: string | null;
-    currentModel?: string;
+    summaryMetadata?: ProviderSummaryMetadata;
     title?: string;
     createdAt: number;
     lastUsedAt: number;