@adhdev/daemon-core 0.8.72 → 0.8.74

package/dist/providers/contracts.d.ts

@@ -356,6 +356,8 @@ export interface ProviderModule {
     resume?: ProviderResumeCapability;
     /** Session ID probe config — auto-discovers provider session ID from local SQLite DB */
     sessionProbe?: ProviderSessionProbe;
+    /** Allow sending another prompt while the CLI is still generating so users can intervene mid-turn. */
+    allowInputDuringGeneration?: boolean;
     /** Approval button priority hints used when auto-approve must pick a positive action */
     approvalPositiveHints?: string[];
     scripts?: ProviderScripts;

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

@@ -1,7 +1,7 @@
 {
   "name": "@adhdev/session-host-core",
-  "version": "0.8.72",
-  "description": "ADHDev local session host core — session registry, protocol, buffers",
+  "version": "0.8.74",
+  "description": "ADHDev local session host core \u2014 session registry, protocol, buffers",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.8.72",
-  "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
+  "version": "0.8.74",
+  "description": "ADHDev daemon core \u2014 CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {

package/src/chat/subscription-updates.ts

@@ -10,7 +10,11 @@ import {
   buildSessionModalDeliverySignature,
 } from './chat-signatures.js'
 
-export interface ChatTailSubscriptionCursor extends Pick<ReadChatCursor, 'knownMessageCount' | 'lastMessageSignature' | 'tailLimit'> {}
+export interface ChatTailSubscriptionCursor {
+  knownMessageCount: number
+  lastMessageSignature: string
+  tailLimit: number
+}
 
 export type SessionChatTailCommandResult = Partial<Omit<ReadChatSyncResult, 'activeModal'>> & {
   success?: boolean

package/src/cli-adapters/provider-cli-adapter.ts

@@ -1439,6 +1439,10 @@ export class ProviderCliAdapter implements CliAdapter {
 
     async sendMessage(text: string): Promise<void> {
         if (!this.ptyProcess) throw new Error(`${this.cliName} is not running`);
+        const allowInputDuringGeneration = this.provider.allowInputDuringGeneration === true;
+        const allowInterventionPrompt = allowInputDuringGeneration
+            && this.isWaitingForResponse
+            && this.currentStatus !== 'waiting_approval';
         if (this.startupParseGate) {
             const deadline = Date.now() + 10000;
             while (this.startupParseGate && Date.now() < deadline) {
@@ -1446,7 +1450,9 @@ export class ProviderCliAdapter implements CliAdapter {
                 await new Promise(resolve => setTimeout(resolve, 50));
             }
         }
-        await this.waitForInteractivePrompt();
+        if (!allowInterventionPrompt) {
+            await this.waitForInteractivePrompt();
+        }
         if (!this.ready) {
             this.resolveStartupState('send_precheck');
             const screenText = this.terminalScreen.getText() || '';
@@ -1458,7 +1464,7 @@ export class ProviderCliAdapter implements CliAdapter {
             }
         }
         if (!this.ready) throw new Error(`${this.cliName} not ready (status: ${this.currentStatus})`);
-        if (this.isWaitingForResponse) {
+        if (this.isWaitingForResponse && !allowInputDuringGeneration) {
             throw new Error(`${this.cliName} is still processing the previous prompt`);
         }
         const blockingModal = this.activeModal || this.getStartupConfirmationModal(this.terminalScreen.getText() || '');

package/src/cli-adapters/provider-cli-shared.d.ts

@@ -105,6 +105,8 @@ export interface CliProviderModule {
     sendDelayMs?: number;
     sendKey?: string;
     submitStrategy?: 'wait_for_echo' | 'immediate';
+    /** Allow sending another prompt while the CLI is still generating so users can intervene mid-turn. */
+    allowInputDuringGeneration?: boolean;
     scripts?: CliScripts;
     spawn: {
         command: string;

package/src/cli-adapters/provider-cli-shared.ts

@@ -110,6 +110,8 @@ export interface CliProviderModule {
     sendDelayMs?: number;
     sendKey?: string;
     submitStrategy?: 'wait_for_echo' | 'immediate';
+    /** Allow sending another prompt while the CLI is still generating so users can intervene mid-turn. */
+    allowInputDuringGeneration?: boolean;
     scripts?: CliScripts;
     spawn: {
         command: string;

package/src/commands/chat-commands.ts

@@ -175,6 +175,48 @@ function normalizeReadChatMessages(payload: Record<string, any>): ChatMessage[]
     return normalizeChatMessages(messages);
 }
 
+function buildReadChatReplayCollapseSignature(message: ChatMessage | null | undefined): string {
+    if (!message) return '';
+    const role = typeof message.role === 'string' ? message.role.trim().toLowerCase() : '';
+    const kind = typeof message.kind === 'string' ? message.kind.trim().toLowerCase() : 'standard';
+    const senderName = typeof message.senderName === 'string' ? message.senderName.trim().toLowerCase() : '';
+    const content = flattenContent(message.content || '').replace(/\s+/g, ' ').trim();
+    return `${role}:${kind}:${senderName}:${content}`;
+}
+
+function shouldCollapseReadChatReplayDuplicate(message: ChatMessage | null | undefined): boolean {
+    if (!message) return false;
+    const role = typeof message.role === 'string' ? message.role.trim().toLowerCase() : '';
+    if (role !== 'assistant' && role !== 'system') return false;
+    const kind = typeof message.kind === 'string' ? message.kind.trim().toLowerCase() : 'standard';
+    return kind === 'tool' || kind === 'terminal' || kind === 'thought' || kind === 'system';
+}
+
+function collapseReplayDuplicatesFromReadChat(messages: ChatMessage[]): ChatMessage[] {
+    const collapsed: ChatMessage[] = [];
+    let lastReplayTurnSignature = '';
+
+    for (const message of messages) {
+        const signature = buildReadChatReplayCollapseSignature(message);
+        const previous = collapsed[collapsed.length - 1];
+        const previousSignature = buildReadChatReplayCollapseSignature(previous);
+
+        if (shouldCollapseReadChatReplayDuplicate(message) && signature) {
+            if (previousSignature === signature) continue;
+            if (lastReplayTurnSignature === signature) continue;
+        }
+
+        collapsed.push(message);
+        if (shouldCollapseReadChatReplayDuplicate(message) && signature) {
+            lastReplayTurnSignature = signature;
+        } else if ((message.role || '').toLowerCase() === 'user') {
+            lastReplayTurnSignature = '';
+        }
+    }
+
+    return collapsed;
+}
+
 function deriveHistoryDedupKey(message: ChatMessage & { _unitKey?: string; _turnKey?: string }): string | undefined {
     const unitKey = typeof message._unitKey === 'string' ? message._unitKey.trim() : '';
     if (unitKey) return `read_chat:${unitKey}`;
@@ -273,14 +315,40 @@ function computeReadChatSync(messages: ChatMessage[], cursor: Required<ReadChatC
     };
 }
 
+function hasNonEmptyModalButtons(activeModal: unknown): boolean {
+    if (!activeModal || typeof activeModal !== 'object') return false;
+    const buttons = (activeModal as { buttons?: unknown }).buttons;
+    return Array.isArray(buttons) && buttons.some((button) => typeof button === 'string' && button.trim().length > 0);
+}
+
+function normalizeReadChatCommandStatus(status: unknown, activeModal: unknown): string {
+    const raw = typeof status === 'string' ? status.trim() : '';
+    if (!raw) {
+        return hasNonEmptyModalButtons(activeModal) ? 'waiting_approval' : 'idle';
+    }
+    switch (raw) {
+        case 'starting':
+            return hasNonEmptyModalButtons(activeModal) ? 'waiting_approval' : 'generating';
+        case 'stopped':
+        case 'disconnected':
+        case 'not_monitored':
+            return 'error';
+        default:
+            return raw;
+    }
+}
+
 function buildReadChatCommandResult(payload: Record<string, any>, args: any): CommandResult {
     let validatedPayload: Record<string, any>;
     try {
-        validatedPayload = validateReadChatResultPayload(payload, 'read_chat command result') as Record<string, any>;
+        validatedPayload = validateReadChatResultPayload({
+            ...payload,
+            status: normalizeReadChatCommandStatus(payload?.status, payload?.activeModal),
+        }, 'read_chat command result') as Record<string, any>;
     } catch (error: any) {
         return { success: false, error: error?.message || String(error) };
     }
-    const messages = normalizeReadChatMessages(validatedPayload);
+    const messages = collapseReplayDuplicatesFromReadChat(normalizeReadChatMessages(validatedPayload));
     const cursor = normalizeReadChatCursor(args);
     if (!cursor.knownMessageCount && !cursor.lastMessageSignature && cursor.tailLimit > 0 && messages.length > cursor.tailLimit) {
         const tailMessages = messages.slice(-cursor.tailLimit);
@@ -374,7 +442,15 @@ export async function handleChatHistory(h: CommandHelpers, args: any): Promise<C
     try {
         const provider = h.getProvider(agentType);
         const agentStr = provider?.type || agentType || getCurrentProviderType(h);
-        const result = readChatHistory(agentStr, offset || 0, limit || 30, historySessionId);
+        const transport = getTargetTransport(h, provider);
+        let excludeRecentCount = Math.max(0, Number(args?.excludeRecentCount || 0));
+        if (isCliLikeTransport(transport)) {
+            const adapter = getTargetedCliAdapter(h, args, provider?.type);
+            const status = adapter?.getStatus?.();
+            const visibleCount = Array.isArray(status?.messages) ? status.messages.length : 0;
+            if (visibleCount > excludeRecentCount) excludeRecentCount = visibleCount;
+        }
+        const result = readChatHistory(agentStr, offset || 0, limit || 30, historySessionId, excludeRecentCount);
         return { success: true, ...result, agent: agentStr };
     } catch (e: any) {
         return { success: false, error: e.message };

package/src/commands/stream-commands.ts

@@ -113,9 +113,6 @@ export async function handleOpenPanel(h: CommandHelpers, args: any): Promise<Com
 export function handlePtyInput(h: CommandHelpers, args: any): CommandResult {
     const { cliType, data, targetSessionId } = args || {};
     if (!data) return { success: false, error: 'data required' };
-    if (getCliPresentationMode(h, targetSessionId) === 'chat') {
-        return { success: false, error: 'CLI session is in chat mode', code: 'CLI_VIEW_MODE_NOT_TERMINAL' };
-    }
     const adapter = h.getCliAdapter(targetSessionId || cliType);
     if (!adapter || typeof adapter.writeRaw !== 'function') {
         return { success: false, error: `CLI adapter not found: ${targetSessionId || cliType || 'unknown'}` };
@@ -124,24 +121,10 @@ export function handlePtyInput(h: CommandHelpers, args: any): CommandResult {
     return { success: true };
 }
 
-export function handlePtyResize(h: CommandHelpers, args: any): CommandResult {
-    const { cliType, cols, rows, force, targetSessionId } = args || {};
+export function handlePtyResize(_h: CommandHelpers, args: any): CommandResult {
+    const { cols, rows } = args || {};
     if (!cols || !rows) return { success: false, error: 'cols and rows required' };
-    if (getCliPresentationMode(h, targetSessionId) === 'chat') {
-        return { success: false, error: 'CLI session is in chat mode', code: 'CLI_VIEW_MODE_NOT_TERMINAL' };
-    }
-    const adapter = h.getCliAdapter(targetSessionId || cliType);
-    if (!adapter || typeof adapter.resize !== 'function') {
-        return { success: false, error: `CLI adapter not found: ${targetSessionId || cliType || 'unknown'}` };
-    }
-    const resize = adapter.resize;
-    if (force) {
-        resize(cols - 1, rows);
-        setTimeout(() => resize(cols, rows), 50);
-    } else {
-        resize(cols, rows);
-    }
-    return { success: true };
+    return { success: false, error: 'PTY resize temporarily disabled', code: 'PTY_RESIZE_DISABLED' };
 }
 
 // ─── Provider Settings ────────────────────────
@@ -251,18 +234,56 @@ export function normalizeProviderScriptArgs(args: any, scriptName?: string): Rec
 
 function buildControlScriptResult(scriptName: string, payload: any): Record<string, unknown> {
     if (!payload || typeof payload !== 'object') return {};
-    if (Array.isArray(payload.options)) {
-        return { controlResult: normalizeControlListResult(payload) };
+
+    const legacyListPayload = (() => {
+        if (Array.isArray(payload.options)) return payload;
+        if (/^listmodels$/i.test(scriptName) && Array.isArray(payload.models)) {
+            return {
+                options: payload.models,
+                currentValue: payload.currentValue ?? payload.current ?? payload.currentModel,
+                ...(typeof payload.error === 'string' ? { error: payload.error } : {}),
+            };
+        }
+        if (/^listmodes$/i.test(scriptName) && Array.isArray(payload.modes)) {
+            return {
+                options: payload.modes,
+                currentValue: payload.currentValue ?? payload.current ?? payload.currentMode ?? payload.mode,
+                ...(typeof payload.error === 'string' ? { error: payload.error } : {}),
+            };
+        }
+        return null;
+    })();
+    if (legacyListPayload) {
+        return { controlResult: normalizeControlListResult(legacyListPayload) };
     }
 
+    const legacyMutationPayload = (() => {
+        if (typeof payload.ok === 'boolean') return payload;
+        if (typeof payload.success === 'boolean') {
+            return {
+                ok: payload.success,
+                currentValue: payload.currentValue
+                    ?? payload.value
+                    ?? payload.model
+                    ?? payload.mode
+                    ?? payload.selectedModel
+                    ?? payload.selectedMode,
+                ...(Array.isArray(payload.effects) ? { effects: payload.effects } : {}),
+                ...(typeof payload.error === 'string' ? { error: payload.error } : {}),
+            };
+        }
+        return null;
+    })();
+
     const looksLikeValueMutation = /^set|^change/i.test(scriptName)
         || payload.currentValue !== undefined
-        || payload.value !== undefined;
+        || payload.value !== undefined
+        || payload.success !== undefined;
     if (looksLikeValueMutation) {
-        return { controlResult: normalizeControlSetResult(payload) };
+        return { controlResult: normalizeControlSetResult(legacyMutationPayload || payload) };
     }
     if (payload.ok !== undefined || Array.isArray(payload.effects) || typeof payload.error === 'string') {
-        return { controlResult: normalizeControlInvokeResult(payload) };
+        return { controlResult: normalizeControlInvokeResult(legacyMutationPayload || payload) };
     }
     return {};
 }
@@ -359,7 +380,7 @@ async function executeProviderScript(h: CommandHelpers, args: any, scriptName: s
 
             // IDE-level scripts (model/mode) — try session frame first, fallback to main page
             const IDE_LEVEL_SCRIPTS = provider.type === 'claude-code-vscode'
-                ? ['listModes', 'setMode']
+                ? ['listModes', 'setMode', 'listModels', 'setModel', 'setModelGui']
                 : ['listModes', 'setMode', 'listModels', 'setModel'];
             if (IDE_LEVEL_SCRIPTS.includes(scriptName)) {
                 // Try session frame first (some extensions embed mode selector in their webview)

package/src/config/chat-history.d.ts

@@ -81,11 +81,12 @@ export declare class ChatHistoryWriter {
 /**
  * Read history (static — called from P2P commands)
  *
- * Read JSONL files in reverse order, returning most recent messages first.
- * When instanceId is specified, reads only that instance file.
- * Offset/limit-based paging.
+ * Read JSONL files for a session and return a chronological page while paging
+ * backwards from the newest saved messages. When excludeRecentCount is set,
+ * the newest N messages are skipped so older-history pagination can avoid
+ * duplicating the live transcript tail already shown in the UI.
  */
-export declare function readChatHistory(agentType: string, offset?: number, limit?: number, historySessionId?: string): {
+export declare function readChatHistory(agentType: string, offset?: number, limit?: number, historySessionId?: string, excludeRecentCount?: number): {
     messages: HistoryMessage[];
     hasMore: boolean;
 };

package/src/config/chat-history.ts

@@ -17,6 +17,13 @@ import { buildRuntimeSystemChatMessage } from '../providers/chat-message-normali
 const HISTORY_DIR = path.join(os.homedir(), '.adhdev', 'history');
 const RETAIN_DAYS = 30;
 
+interface SavedHistorySessionCacheEntry {
+    signature: string;
+    summaries: SavedHistorySessionSummary[];
+}
+
+const savedHistorySessionCache = new Map<string, SavedHistorySessionCacheEntry>();
+
 interface HistoryMessage {
     ts: string;           // ISO timestamp
     receivedAt: number;   // epoch ms
@@ -128,6 +135,96 @@ export interface SavedHistorySessionSummary {
     workspace?: string;
 }
 
+function sanitizeHistoryFileSegment(value?: string): string {
+    return String(value || '').replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+
+function listHistoryFiles(dir: string, historySessionId?: string): string[] {
+    const sanitizedSessionId = historySessionId ? sanitizeHistoryFileSegment(historySessionId) : '';
+    return fs.readdirSync(dir)
+        .filter((file) => {
+            if (!file.endsWith('.jsonl')) return false;
+            if (sanitizedSessionId) {
+                return file.startsWith(`${sanitizedSessionId}_`);
+            }
+            return true;
+        })
+        .sort()
+        .reverse();
+}
+
+function buildSavedHistoryCacheSignature(dir: string, files: string[]): string {
+    return files.map((file) => {
+        try {
+            const stat = fs.statSync(path.join(dir, file));
+            return `${file}:${stat.size}:${Math.trunc(stat.mtimeMs)}`;
+        } catch {
+            return `${file}:missing`;
+        }
+    }).join('|');
+}
+
+function computeSavedHistorySessionSummaries(agentType: string, dir: string, files: string[]): SavedHistorySessionSummary[] {
+    const groupedFiles = new Map<string, string[]>();
+    const filePattern = /^([A-Za-z0-9_-]+)_\d{4}-\d{2}-\d{2}\.jsonl$/;
+    for (const file of files) {
+        const match = file.match(filePattern);
+        if (!match?.[1]) continue;
+        const historySessionId = match[1];
+        const grouped = groupedFiles.get(historySessionId) || [];
+        grouped.push(file);
+        groupedFiles.set(historySessionId, grouped);
+    }
+
+    const summaries: SavedHistorySessionSummary[] = [];
+    for (const [historySessionId, grouped] of groupedFiles.entries()) {
+        let messageCount = 0;
+        let firstMessageAt = 0;
+        let lastMessageAt = 0;
+        let sessionTitle = '';
+        let preview = '';
+        let workspace = '';
+
+        for (const file of grouped.sort()) {
+            const filePath = path.join(dir, file);
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const lines = content.split('\n').filter(Boolean);
+            for (const line of lines) {
+                let parsed: HistoryMessage | null = null;
+                try {
+                    parsed = JSON.parse(line) as HistoryMessage;
+                } catch {
+                    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;
+                if (parsed.sessionTitle) sessionTitle = parsed.sessionTitle;
+                if (parsed.role !== 'system' && parsed.content.trim()) preview = parsed.content.trim();
+            }
+        }
+
+        if (messageCount === 0 || !lastMessageAt) continue;
+        summaries.push({
+            historySessionId,
+            sessionTitle: sessionTitle || undefined,
+            messageCount,
+            firstMessageAt,
+            lastMessageAt,
+            preview: preview || undefined,
+            workspace: workspace || undefined,
+        });
+    }
+
+    summaries.sort((a, b) => b.lastMessageAt - a.lastMessageAt);
+    return summaries;
+}
+
 export class ChatHistoryWriter {
 /** Last seen message count per agent (deduplication) */
     private lastSeenCounts = new Map<string, number>();
@@ -539,15 +636,17 @@ export class ChatHistoryWriter {
 /**
  * Read history (static — called from P2P commands)
  * 
- * Read JSONL files in reverse order, returning most recent messages first.
- * When instanceId is specified, reads only that instance file.
- * Offset/limit-based paging.
+ * Read JSONL files for a session and return a chronological page while paging
+ * backwards from the newest saved messages. When excludeRecentCount is set,
+ * the newest N messages are skipped so older-history pagination can avoid
+ * duplicating the live transcript tail already shown in the UI.
  */
 export function readChatHistory(
     agentType: string,
     offset: number = 0,
     limit: number = 30,
     historySessionId?: string,
+    excludeRecentCount: number = 0,
 ): { messages: HistoryMessage[]; hasMore: boolean } {
     try {
         const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, '_');
@@ -555,19 +654,7 @@ export function readChatHistory(
         if (!fs.existsSync(dir)) return { messages: [], hasMore: false };
 
  // JSONL file list — filter by persistent history key when specified
-        const sanitizedInstance = historySessionId?.replace(/[^a-zA-Z0-9_-]/g, '_');
-        const files = fs.readdirSync(dir)
-            .filter(f => {
-                if (!f.endsWith('.jsonl')) return false;
-                if (sanitizedInstance) {
-                    // With instanceId: only that instance's files
-                    return f.startsWith(`${sanitizedInstance}_`);
-                }
-                // Without instanceId: include ALL files (legacy + instanced)
-                return true;
-            })
-            .sort()
-            .reverse();
+        const files = listHistoryFiles(dir, historySessionId);
 
         const allMessages: HistoryMessage[] = [];
         const seen = new Set<string>();
@@ -602,9 +689,15 @@ export function readChatHistory(
         }
         const collapsed = collapseReplayAssistantTurns(agentType, chronological);
 
- // offset/limit apply
-        const sliced = collapsed.slice(offset, offset + limit);
-        const hasMore = collapsed.length > offset + limit;
+ // Page backwards from the newest saved messages while keeping the returned
+ // slice in chronological order for prepend-based UI rendering.
+        const boundedLimit = Math.max(1, limit);
+        const boundedOffset = Math.max(0, offset);
+        const boundedExclude = Math.max(0, Math.min(excludeRecentCount, collapsed.length));
+        const endExclusive = Math.max(0, collapsed.length - boundedExclude - boundedOffset);
+        const startInclusive = Math.max(0, endExclusive - boundedLimit);
+        const sliced = collapsed.slice(startInclusive, endExclusive);
+        const hasMore = startInclusive > 0;
 
         return { messages: sliced, hasMore };
     } catch {
@@ -619,66 +712,24 @@ export function listSavedHistorySessions(
     try {
         const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, '_');
         const dir = path.join(HISTORY_DIR, sanitized);
-        if (!fs.existsSync(dir)) return { sessions: [], hasMore: false };
-
-        const groupedFiles = new Map<string, string[]>();
-        const filePattern = /^([A-Za-z0-9_-]+)_\d{4}-\d{2}-\d{2}\.jsonl$/;
-        for (const file of fs.readdirSync(dir)) {
-            if (!file.endsWith('.jsonl')) continue;
-            const match = file.match(filePattern);
-            if (!match?.[1]) continue;
-            const historySessionId = match[1];
-            const files = groupedFiles.get(historySessionId) || [];
-            files.push(file);
-            groupedFiles.set(historySessionId, files);
+        if (!fs.existsSync(dir)) {
+            savedHistorySessionCache.delete(sanitized);
+            return { sessions: [], hasMore: false };
         }
 
-        const summaries: SavedHistorySessionSummary[] = [];
-        for (const [historySessionId, files] of groupedFiles.entries()) {
-            let messageCount = 0;
-            let firstMessageAt = 0;
-            let lastMessageAt = 0;
-            let sessionTitle = '';
-            let preview = '';
-            let workspace = '';
-
-            for (const file of files.sort()) {
-                const filePath = path.join(dir, file);
-                const content = fs.readFileSync(filePath, 'utf-8');
-                const lines = content.split('\n').filter(Boolean);
-                for (const line of lines) {
-                    let parsed: HistoryMessage | null = null;
-                    try {
-                        parsed = JSON.parse(line) as HistoryMessage;
-                    } catch {
-                        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;
-                    if (parsed.sessionTitle) sessionTitle = parsed.sessionTitle;
-                    if (parsed.role !== 'system' && parsed.content.trim()) preview = parsed.content.trim();
-                }
-            }
-
-            if (messageCount === 0 || !lastMessageAt) continue;
-            summaries.push({
-                historySessionId,
-                sessionTitle: sessionTitle || undefined,
-                messageCount,
-                firstMessageAt,
-                lastMessageAt,
-                preview: preview || undefined,
-                workspace: workspace || undefined,
+        const files = listHistoryFiles(dir);
+        const signature = buildSavedHistoryCacheSignature(dir, files);
+        const cached = savedHistorySessionCache.get(sanitized);
+        const summaries = cached?.signature === signature
+            ? cached.summaries
+            : computeSavedHistorySessionSummaries(agentType, dir, files);
+        if (!cached || cached.signature !== signature) {
+            savedHistorySessionCache.set(sanitized, {
+                signature,
+                summaries,
             });
         }
 
-        summaries.sort((a, b) => b.lastMessageAt - a.lastMessageAt);
         const offset = Math.max(0, options.offset || 0);
         const limit = Math.max(1, options.limit || 30);
         const sliced = summaries.slice(offset, offset + limit);

package/src/daemon/dev-server.ts

@@ -507,6 +507,20 @@ export class DevServer implements DevServerContext {
   private async handleReload(_req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
     try {
       this.providerLoader.reload();
+      let refreshedInstances = 0;
+      if (this.instanceManager) {
+        for (const id of this.instanceManager.listInstanceIds()) {
+          const instance = this.instanceManager.getInstance(id) as any;
+          const providerType = typeof instance?.type === 'string' ? instance.type : '';
+          if (!providerType) continue;
+          const resolved = this.providerLoader.resolve(providerType);
+          if (!resolved) continue;
+          if (instance && typeof instance === 'object' && 'provider' in instance) {
+            instance.provider = resolved;
+            refreshedInstances += 1;
+          }
+        }
+      }
       const providers = this.providerLoader.getAll().map(p => ({
         type: p.type, name: p.name, category: p.category,
       }));
@@ -515,7 +529,7 @@ export class DevServer implements DevServerContext {
           cdp.clearTargetId();
         }
       }
-      this.json(res, 200, { reloaded: true, providers });
+      this.json(res, 200, { reloaded: true, refreshedInstances, providers });
     } catch (e: any) {
       this.json(res, 500, { error: e.message });
     }

package/src/providers/approval-utils.ts

@@ -1,24 +1,25 @@
 import type { ProviderModule } from './contracts.js';
 
 const DEFAULT_APPROVAL_POSITIVE_HINTS = [
-    'run',
+    'yes',
+    'allow once',
     'approve',
     'accept',
-    'allow once',
-    'always allow',
-    'allow',
-    'yes',
-    'proceed',
     'continue',
+    'run',
+    'proceed',
     'confirm',
     'save',
     'ok',
     'trust',
+    'allow',
+    'always allow',
 ];
 
 function normalizeApprovalLabel(value: string): string {
     return String(value || '')
         .toLowerCase()
+        .replace(/^[\s\[(<{]*\d+(?:\s*[.)\]}>:-]|\s)+/, '')
         .replace(/[^\p{L}\p{N}]+/gu, ' ')
         .trim();
 }

package/src/providers/contracts.d.ts

@@ -333,6 +333,8 @@ export interface ProviderModule {
     resume?: ProviderResumeCapability;
     /** Session ID probe config — auto-discovers provider session ID from local SQLite DB */
     sessionProbe?: ProviderSessionProbe;
+    /** Allow sending another prompt while the CLI is still generating so users can intervene mid-turn. */
+    allowInputDuringGeneration?: boolean;
     /** Approval button priority hints used when auto-approve must pick a positive action */
     approvalPositiveHints?: string[];
     scripts?: ProviderScripts;