@adhdev/daemon-core 0.8.28 → 0.8.29

package/src/agent-stream/provider-adapter.ts

@@ -70,6 +70,64 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
             || /Cannot find context with specified id/i.test(reason);
     }
 
+    private titlesMatch(actual: string, expected: string): boolean {
+        const lhs = actual.trim().toLowerCase();
+        const rhs = expected.trim().toLowerCase();
+        if (!lhs || !rhs) return false;
+        return lhs === rhs || lhs.includes(rhs) || rhs.includes(lhs);
+    }
+
+    private messageCount(state: AgentStreamState | null | undefined): number {
+        return Array.isArray(state?.messages) ? state!.messages.length : 0;
+    }
+
+    private lastMessageSignature(state: AgentStreamState | null | undefined): string {
+        const messages = Array.isArray(state?.messages) ? state!.messages : [];
+        const last = messages[messages.length - 1] as any;
+        if (!last) return '';
+        return `${last.role || ''}:${String(last.content || '').replace(/\s+/g, ' ').trim()}`;
+    }
+
+    private async verifySendOutcome(
+        evaluate: AgentEvaluateFn,
+        before: AgentStreamState | null,
+    ): Promise<boolean> {
+        const beforeCount = this.messageCount(before);
+        const beforeSignature = this.lastMessageSignature(before);
+
+        for (let attempt = 0; attempt < 12; attempt += 1) {
+            await new Promise((resolve) => setTimeout(resolve, 250));
+            let state: AgentStreamState;
+            try {
+                state = await this.readChat(evaluate);
+            } catch {
+                continue;
+            }
+
+            if (state.status === 'waiting_approval') {
+                return true;
+            }
+
+            const afterCount = this.messageCount(state);
+            const afterSignature = this.lastMessageSignature(state);
+            if (afterCount > beforeCount) return true;
+            if (afterSignature && afterSignature !== beforeSignature) return true;
+        }
+
+        return false;
+    }
+
+    private async readStableBaselineState(evaluate: AgentEvaluateFn): Promise<AgentStreamState | null> {
+        const first = await this.readChat(evaluate);
+        if (this.messageCount(first) > 0 || this.lastMessageSignature(first)) {
+            return first;
+        }
+
+        await new Promise((resolve) => setTimeout(resolve, 150));
+        const second = await this.readChat(evaluate);
+        return this.messageCount(second) >= this.messageCount(first) ? second : first;
+    }
+
     async readChat(evaluate: AgentEvaluateFn): Promise<AgentStreamState> {
         const script = this.callScript('readChat');
         if (!script) return this.errorState('readChat script not available');
@@ -96,6 +154,9 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
                 mode: data.mode,
                 activeModal: data.activeModal,
             };
+            if (typeof data.title === 'string' && data.title.trim()) {
+                (state as any).title = data.title.trim();
+            }
             const controlValues = extractProviderControlValues(this.provider.controls, data);
             if (controlValues) state.controlValues = controlValues;
             const effects = normalizeProviderEffects(data);
@@ -120,6 +181,13 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
     }
 
     async sendMessage(evaluate: AgentEvaluateFn, text: string): Promise<void> {
+        let beforeState: AgentStreamState | null = null;
+        try {
+            beforeState = await this.readStableBaselineState(evaluate);
+        } catch {
+            beforeState = null;
+        }
+
         const params = { message: text };
         const script = this.callScript('sendMessage', params) || this.callScript('sendMessage', text);
         if (!script) throw new Error(`[${this.agentName}] sendMessage script not available`);
@@ -138,7 +206,9 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
         }
         if (parsed && typeof parsed === 'object') {
             if (parsed.sent === true || parsed.success === true || parsed.ok === true || parsed.submitted === true || parsed.dispatched === true) {
-                return;
+                const verified = await this.verifySendOutcome(evaluate, beforeState);
+                if (verified) return;
+                throw new Error(`[${this.agentName}] sendMessage was not observed in chat state`);
             }
             if (typeof parsed.error === 'string' && parsed.error.trim()) {
                 throw new Error(`[${this.agentName}] sendMessage failed: ${parsed.error}`);
@@ -151,7 +221,23 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
     async resolveAction(evaluate: AgentEvaluateFn, action: string, button?: string): Promise<boolean> {
         const script = this.callScript('resolveAction', { action, button });
         if (!script) return false; // Not supported if provider has no resolveAction
-        return (await evaluate(script)) === true;
+        const result = await evaluate(script);
+        const parsed = this.parseMaybeJson(result);
+        if (parsed === true) return true;
+        if (typeof parsed === 'string') {
+            const normalized = parsed.trim().toLowerCase();
+            return normalized === 'ok'
+                || normalized === 'success'
+                || normalized === 'true'
+                || normalized === 'resolved'
+                || normalized === 'approved'
+                || normalized === 'rejected';
+        }
+        if (!parsed || typeof parsed !== 'object') return false;
+        return parsed.resolved === true
+            || parsed.success === true
+            || parsed.ok === true
+            || parsed.found === true;
     }
 
     async newSession(evaluate: AgentEvaluateFn): Promise<void> {
@@ -189,7 +275,15 @@ export class ProviderStreamAdapter implements IAgentStreamAdapter {
             return normalized === 'true' || normalized === 'ok' || normalized === 'switched' || normalized === 'success';
         }
         if (data && typeof data === 'object') {
-            return data.switched === true || data.success === true || data.ok === true;
+            if (data.switched === true || data.success === true || data.ok === true) return true;
+            if (typeof data.error === 'string' && data.error.trim()) return false;
+        }
+
+        for (let attempt = 0; attempt < 6; attempt += 1) {
+            await new Promise((resolve) => setTimeout(resolve, 250));
+            const state = await this.readChat(evaluate);
+            const title = typeof (state as any).title === 'string' ? (state as any).title : '';
+            if (this.titlesMatch(title, sessionId)) return true;
         }
         return false;
     }

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

@@ -1241,6 +1241,9 @@ export class ProviderCliAdapter implements CliAdapter {
     private looksLikeVisibleIdlePrompt(screenText: string): boolean {
         const text = String(screenText || '');
         if (!text.trim()) return false;
+        if (this.cliType === 'codex-cli' && /(^|\n)\s*[❯›>]\s+(?:Find and fix a bug in @filename|Improve documentation in @filename|Use \/skills|Write tests for @filename|Explain this codebase|Summarize recent commits|Implement \{feature\}|Run \/review on my current changes)(?:\n|$)/im.test(text)) {
+            return true;
+        }
         return /(^|\n)\s*[❯›>]\s*(?:\n|$)/m.test(text)
             || /⏎\s+send/i.test(text)
             || /\?\s*for\s*shortcuts/i.test(text)

package/src/commands/chat-commands.ts

@@ -115,6 +115,51 @@ function didProviderConfirmSend(result: any): boolean {
         || parsed.dispatched === true;
 }
 
+async function readExtensionChatState(h: CommandHelpers): Promise<any | null> {
+    try {
+        const evalResult = await h.evaluateProviderScript('readChat', undefined, 50000);
+        if (!evalResult?.result) return null;
+        const parsed = parseMaybeJson(evalResult.result);
+        return parsed && typeof parsed === 'object' ? parsed : null;
+    } catch {
+        return null;
+    }
+}
+
+function getStateMessageCount(state: any): number {
+    return Array.isArray(state?.messages) ? state.messages.length : 0;
+}
+
+function getStateLastSignature(state: any): string {
+    const messages = Array.isArray(state?.messages) ? state.messages : [];
+    const last = messages[messages.length - 1];
+    if (!last) return '';
+    return `${last.role || ''}:${String(last.content || '').replace(/\s+/g, ' ').trim()}`;
+}
+
+async function getStableExtensionBaseline(h: CommandHelpers): Promise<any | null> {
+    const first = await readExtensionChatState(h);
+    if (getStateMessageCount(first) > 0 || getStateLastSignature(first)) return first;
+    await new Promise((resolve) => setTimeout(resolve, 150));
+    const second = await readExtensionChatState(h);
+    return getStateMessageCount(second) >= getStateMessageCount(first) ? second : first;
+}
+
+async function verifyExtensionSendObserved(h: CommandHelpers, before: any): Promise<boolean> {
+    const beforeCount = getStateMessageCount(before);
+    const beforeSignature = getStateLastSignature(before);
+    for (let attempt = 0; attempt < 12; attempt += 1) {
+        await new Promise((resolve) => setTimeout(resolve, 250));
+        const state = await readExtensionChatState(h);
+        if (state?.status === 'waiting_approval') return true;
+        const afterCount = getStateMessageCount(state);
+        const afterSignature = getStateLastSignature(state);
+        if (afterCount > beforeCount) return true;
+        if (afterSignature && afterSignature !== beforeSignature) return true;
+    }
+    return false;
+}
+
 export async function handleChatHistory(h: CommandHelpers, args: any): Promise<CommandResult> {
     const { agentType, offset, limit } = args;
     const historySessionId = getHistorySessionId(h, args);
@@ -303,12 +348,17 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
         _log(`Extension: ${provider?.type || 'unknown_extension'}`);
         // Method 1: provider sendMessage script via evaluateInSession
         try {
+            const beforeState = await getStableExtensionBaseline(h);
             const evalResult = await h.evaluateProviderScript('sendMessage', { message: text }, 30000);
             if (evalResult?.result) {
                 const parsed = parseMaybeJson(evalResult.result);
                 if (didProviderConfirmSend(parsed)) {
-                    _log(`Extension script sent OK`);
-                    return _logSendSuccess('extension-script');
+                    const observed = await verifyExtensionSendObserved(h, beforeState);
+                    if (observed) {
+                        _log(`Extension script sent OK`);
+                        return _logSendSuccess('extension-script');
+                    }
+                    _log(`Extension script reported send but no chat-state change was observed`);
                 }
                 if (parsed?.needsTypeAndSend) {
                     _log(`Extension needsTypeAndSend → AgentStreamManager`);
@@ -829,7 +879,7 @@ export async function handleResolveAction(h: CommandHelpers, args: any): Promise
 
     // 1. Extension transport: via AgentStreamManager
     if (isExtensionTransport(transport) && h.agentStream && h.getCdp() && h.currentSession?.sessionId) {
-        const ok = await h.agentStream.resolveSessionAction(h.getCdp()!, h.currentSession.sessionId, action);
+        const ok = await h.agentStream.resolveSessionAction(h.getCdp()!, h.currentSession.sessionId, action, button);
         return { success: ok };
     }
 

package/src/commands/cli-manager.ts

@@ -687,6 +687,7 @@ export class DaemonCliManager {
         if (!instanceManager) return 0;
         const sessions = records || await this.deps.listHostedCliRuntimes?.() || [];
         let restored = 0;
+        const restoredBindings = new Set<string>();
 
         for (const record of sessions) {
             if (!record?.runtimeId || !record?.cliType || !record?.workspace) continue;
@@ -702,6 +703,18 @@ export class DaemonCliManager {
                 record.cliArgs,
                 record.providerSessionId,
             );
+            const bindingKey = [
+                normalizedType,
+                record.workspace,
+                sessionBinding.providerSessionId || record.runtimeId,
+            ].join('::');
+            if (restoredBindings.has(bindingKey)) {
+                LOG.info(
+                    'CLI',
+                    `↷ Skipping duplicate hosted runtime restore: ${record.runtimeKey || record.runtimeId} (${normalizedType} @ ${record.workspace}) binding=${sessionBinding.providerSessionId || 'runtime'}`
+                );
+                continue;
+            }
             try {
                 await this.registerCliInstance(
                     record.runtimeId,
@@ -717,6 +730,7 @@ export class DaemonCliManager {
                         launchMode: 'manual',
                     },
                 );
+                restoredBindings.add(bindingKey);
                 restored += 1;
                 LOG.info('CLI', `♻ Restored hosted runtime: ${record.runtimeKey || record.runtimeId} (${record.displayName || record.workspace})`);
             } catch (error: any) {

package/src/commands/router.ts

@@ -44,6 +44,7 @@ export interface SessionHostControlPlane {
     restartSession(sessionId: string): Promise<any>;
     sendSignal(sessionId: string, signal: string): Promise<any>;
     forceDetachClient(sessionId: string, clientId: string): Promise<any>;
+    pruneDuplicateSessions(payload?: { providerType?: string; workspace?: string; dryRun?: boolean }): Promise<any>;
     acquireWrite(payload: { sessionId: string; clientId: string; ownerType: 'agent' | 'user'; force?: boolean }): Promise<any>;
     releaseWrite(payload: { sessionId: string; clientId: string }): Promise<any>;
 }
@@ -265,6 +266,16 @@ export class DaemonCommandRouter {
                 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({
+                    providerType: typeof args?.providerType === 'string' ? args.providerType : undefined,
+                    workspace: typeof args?.workspace === 'string' ? args.workspace : undefined,
+                    dryRun: args?.dryRun === true,
+                });
+                return { success: true, result };
+            }
+
             case 'session_host_acquire_write': {
                 if (!this.deps.sessionHostControl) return { success: false, error: 'Session host control unavailable' };
                 const sessionId = typeof args?.sessionId === 'string' ? args.sessionId : '';

package/src/config/chat-history.ts

@@ -29,6 +29,93 @@ interface HistoryMessage {
     sessionTitle?: string;
 }
 
+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;
+
+function normalizeHistoryComparable(text: string): string {
+    return String(text || '').replace(/\s+/g, ' ').trim();
+}
+
+function cleanupHistoryContent(agentType: string, role: HistoryMessage['role'], content: string): string {
+    let value = String(content || '').replace(/\r\n/g, '\n').trim();
+    if (!value) return '';
+
+    if (agentType === 'codex-cli' && role === 'assistant') {
+        const filtered = value
+            .split('\n')
+            .filter((line) => !CODEX_STARTER_PROMPT_RE.test(line.trim()))
+            .join('\n')
+            .replace(/\n{3,}/g, '\n\n')
+            .trim();
+        value = filtered;
+    }
+
+    return value;
+}
+
+function buildHistoryMessageHash(
+    agentType: string,
+    message: Pick<HistoryMessage, 'role' | 'content' | 'receivedAt' | 'kind'> & { historyDedupKey?: string },
+): string {
+    if (message.historyDedupKey) return message.historyDedupKey;
+    const cleaned = cleanupHistoryContent(agentType, message.role, message.content);
+    return `${message.kind || 'standard'}:${message.role}:${message.receivedAt || 0}:${normalizeHistoryComparable(cleaned)}`;
+}
+
+function buildHistoryMessageSignature(
+    agentType: string,
+    message: Pick<HistoryMessage, 'role' | 'content' | 'kind'>,
+): string {
+    const cleaned = cleanupHistoryContent(agentType, message.role, message.content);
+    return `${message.kind || 'standard'}:${message.role}:${normalizeHistoryComparable(cleaned)}`;
+}
+
+function isAdjacentHistoryDuplicate(
+    agentType: string,
+    previous: Pick<HistoryMessage, 'role' | 'content' | 'kind'> | null | undefined,
+    next: Pick<HistoryMessage, 'role' | 'content' | 'kind'> | null | undefined,
+): boolean {
+    if (!previous || !next) return false;
+    return buildHistoryMessageSignature(agentType, previous) === buildHistoryMessageSignature(agentType, next);
+}
+
+function collapseReplayAssistantTurns(agentType: string, messages: HistoryMessage[]): HistoryMessage[] {
+    if (agentType !== 'codex-cli') return messages;
+
+    const collapsed: HistoryMessage[] = [];
+    let sawAssistantSinceLastUser = false;
+
+    for (const message of messages) {
+        if (message.role === 'user') {
+            sawAssistantSinceLastUser = false;
+            collapsed.push(message);
+            continue;
+        }
+
+        if (message.role === 'assistant') {
+            if (sawAssistantSinceLastUser) continue;
+            sawAssistantSinceLastUser = true;
+            collapsed.push(message);
+            continue;
+        }
+
+        collapsed.push(message);
+    }
+
+    return collapsed;
+}
+
+function sanitizeHistoryMessage(agentType: string, message: HistoryMessage): HistoryMessage | null {
+    if (!message || (message.role !== 'user' && message.role !== 'assistant' && message.role !== 'system')) {
+        return null;
+    }
+    const content = cleanupHistoryContent(agentType, message.role, message.content);
+    if (!content) return null;
+    return {
+        ...message,
+        content,
+    };
+}
+
 export interface SavedHistorySessionSummary {
     historySessionId: string;
     sessionTitle?: string;
@@ -43,6 +130,10 @@ export class ChatHistoryWriter {
     private lastSeenCounts = new Map<string, number>();
 /** Last seen message hash per agent (deduplication) */
     private lastSeenHashes = new Map<string, Set<string>>();
+/** Last appended normalized message signature per agent/session */
+    private lastSeenSignatures = new Map<string, string>();
+/** Last appended normalized non-system turn signature per agent/session */
+    private lastSeenTurnSignatures = new Map<string, string>();
     private rotated = false;
 
  /**
@@ -75,14 +166,36 @@ export class ChatHistoryWriter {
  // Filter new messages
             const newMessages: HistoryMessage[] = [];
             for (const msg of messages) {
-                const hash = msg.historyDedupKey || `${msg.kind || 'standard'}:${msg.role}:${(msg.content || '').slice(0, 50)}`;
+                const role = msg.role as 'user' | 'assistant' | 'system';
+                if (role !== 'user' && role !== 'assistant' && role !== 'system') continue;
+                const content = cleanupHistoryContent(agentType, role, msg.content || '');
+                if (!content) continue;
+                const receivedAt = msg.receivedAt || Date.now();
+                const hash = buildHistoryMessageHash(agentType, {
+                    role,
+                    content,
+                    receivedAt,
+                    kind: typeof msg.kind === 'string' ? msg.kind : undefined,
+                    historyDedupKey: msg.historyDedupKey,
+                });
+                const signature = buildHistoryMessageSignature(agentType, {
+                    role,
+                    content,
+                    kind: typeof msg.kind === 'string' ? msg.kind : undefined,
+                });
                 if (seenHashes.has(hash)) continue;
+                if (this.lastSeenSignatures.get(dedupKey) === signature) continue;
+                if (role !== 'system' && this.lastSeenTurnSignatures.get(dedupKey) === signature) continue;
                 seenHashes.add(hash);
+                this.lastSeenSignatures.set(dedupKey, signature);
+                if (role !== 'system') {
+                    this.lastSeenTurnSignatures.set(dedupKey, signature);
+                }
                 newMessages.push({
-                    ts: new Date(msg.receivedAt || Date.now()).toISOString(),
-                    receivedAt: msg.receivedAt || Date.now(),
-                    role: msg.role as 'user' | 'assistant' | 'system',
-                    content: msg.content || '',
+                    ts: new Date(receivedAt).toISOString(),
+                    receivedAt,
+                    role,
+                    content,
                     kind: typeof msg.kind === 'string' ? msg.kind : undefined,
                     senderName: typeof msg.senderName === 'string' ? msg.senderName : undefined,
                     agent: agentType,
@@ -108,6 +221,8 @@ export class ChatHistoryWriter {
             const prevCount = this.lastSeenCounts.get(dedupKey) || 0;
             if (messages.length < prevCount * 0.5 && prevCount > 3) {
                 seenHashes.clear();
+                this.lastSeenSignatures.delete(dedupKey);
+                this.lastSeenTurnSignatures.delete(dedupKey);
                 for (const msg of messages) {
                     seenHashes.add(msg.historyDedupKey || `${msg.kind || 'standard'}:${msg.role}:${(msg.content || '').slice(0, 50)}`);
                 }
@@ -124,6 +239,62 @@ export class ChatHistoryWriter {
         }
     }
 
+    seedSessionHistory(
+        agentType: string,
+        messages: Array<{ role: string; content: string; receivedAt?: number; kind?: string; historyDedupKey?: string }> = [],
+        historySessionId?: string,
+        instanceId?: string,
+    ): void {
+        const effectiveHistoryKey = historySessionId || instanceId;
+        const dedupKey = effectiveHistoryKey ? `${agentType}:${effectiveHistoryKey}` : agentType;
+        const seenHashes = new Set<string>();
+
+        for (const raw of messages) {
+            const role = raw?.role as 'user' | 'assistant' | 'system';
+            if (role !== 'user' && role !== 'assistant' && role !== 'system') continue;
+            const content = cleanupHistoryContent(agentType, role, raw?.content || '');
+            if (!content) continue;
+            seenHashes.add(buildHistoryMessageHash(agentType, {
+                role,
+                content,
+                receivedAt: raw?.receivedAt || 0,
+                kind: typeof raw?.kind === 'string' ? raw.kind : undefined,
+                historyDedupKey: raw?.historyDedupKey,
+            }));
+        }
+
+        this.lastSeenHashes.set(dedupKey, seenHashes);
+        this.lastSeenCounts.set(dedupKey, messages.length);
+        const lastMessage = [...messages].reverse().find((raw) => {
+            const role = raw?.role as 'user' | 'assistant' | 'system';
+            if (role !== 'user' && role !== 'assistant' && role !== 'system') return false;
+            return !!cleanupHistoryContent(agentType, role, raw?.content || '');
+        });
+        const lastTurnMessage = [...messages].reverse().find((raw) => {
+            const role = raw?.role as 'user' | 'assistant';
+            if (role !== 'user' && role !== 'assistant') return false;
+            return !!cleanupHistoryContent(agentType, role, raw?.content || '');
+        });
+        if (lastMessage) {
+            this.lastSeenSignatures.set(dedupKey, buildHistoryMessageSignature(agentType, {
+                role: lastMessage.role as HistoryMessage['role'],
+                content: lastMessage.content,
+                kind: typeof lastMessage.kind === 'string' ? lastMessage.kind : undefined,
+            }));
+        } else {
+            this.lastSeenSignatures.delete(dedupKey);
+        }
+        if (lastTurnMessage) {
+            this.lastSeenTurnSignatures.set(dedupKey, buildHistoryMessageSignature(agentType, {
+                role: lastTurnMessage.role as 'user' | 'assistant',
+                content: lastTurnMessage.content,
+                kind: typeof lastTurnMessage.kind === 'string' ? lastTurnMessage.kind : undefined,
+            }));
+        } else {
+            this.lastSeenTurnSignatures.delete(dedupKey);
+        }
+    }
+
     appendSystemMarker(
         agentType: string,
         content: string,
@@ -171,6 +342,16 @@ export class ChatHistoryWriter {
                 this.lastSeenHashes.set(toDedupKey, nextHashes);
                 this.lastSeenHashes.delete(fromDedupKey);
             }
+            const fromSignature = this.lastSeenSignatures.get(fromDedupKey);
+            if (fromSignature) {
+                this.lastSeenSignatures.set(toDedupKey, fromSignature);
+                this.lastSeenSignatures.delete(fromDedupKey);
+            }
+            const fromTurnSignature = this.lastSeenTurnSignatures.get(fromDedupKey);
+            if (fromTurnSignature) {
+                this.lastSeenTurnSignatures.set(toDedupKey, fromTurnSignature);
+                this.lastSeenTurnSignatures.delete(fromDedupKey);
+            }
             const fromCount = this.lastSeenCounts.get(fromDedupKey);
             if (typeof fromCount === 'number') {
                 this.lastSeenCounts.set(toDedupKey, Math.max(fromCount, this.lastSeenCounts.get(toDedupKey) || 0));
@@ -221,10 +402,69 @@ export class ChatHistoryWriter {
         }
     }
 
+    compactHistorySession(agentType: string, historySessionId: string): void {
+        const sessionId = String(historySessionId || '').trim();
+        if (!sessionId) return;
+
+        try {
+            const dir = path.join(HISTORY_DIR, this.sanitize(agentType));
+            if (!fs.existsSync(dir)) return;
+
+            const prefix = `${this.sanitize(sessionId)}_`;
+            const files = fs.readdirSync(dir)
+                .filter((file) => file.startsWith(prefix) && file.endsWith('.jsonl'))
+                .sort();
+
+            const seen = new Set<string>();
+            for (const file of files) {
+                const filePath = path.join(dir, file);
+                const lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(Boolean);
+                const next: HistoryMessage[] = [];
+
+                for (const line of lines) {
+                    let parsed: HistoryMessage | null = null;
+                    try {
+                        parsed = JSON.parse(line) as HistoryMessage;
+                    } catch {
+                        parsed = null;
+                    }
+                    if (!parsed || parsed.historySessionId !== sessionId) continue;
+                    const sanitized = sanitizeHistoryMessage(agentType, parsed);
+                    if (!sanitized) continue;
+                    const hash = buildHistoryMessageHash(agentType, sanitized);
+                    if (seen.has(hash)) continue;
+                    seen.add(hash);
+                    next.push(sanitized);
+                }
+
+                next.sort((a, b) => a.receivedAt - b.receivedAt);
+                const dedupedAdjacent: HistoryMessage[] = [];
+                let lastTurn: HistoryMessage | null = null;
+                for (const entry of next) {
+                    const previous = dedupedAdjacent[dedupedAdjacent.length - 1];
+                    if (isAdjacentHistoryDuplicate(agentType, previous, entry)) continue;
+                    if (entry.role !== 'system' && isAdjacentHistoryDuplicate(agentType, lastTurn, entry)) continue;
+                    dedupedAdjacent.push(entry);
+                    if (entry.role !== 'system') lastTurn = entry;
+                }
+                const collapsed = collapseReplayAssistantTurns(agentType, dedupedAdjacent);
+                if (collapsed.length === 0) {
+                    fs.unlinkSync(filePath);
+                    continue;
+                }
+                fs.writeFileSync(filePath, `${collapsed.map((entry) => JSON.stringify(entry)).join('\n')}\n`, 'utf-8');
+            }
+        } catch {
+            // Ignore compaction failure.
+        }
+    }
+
 /** Called when agent session is explicitly changed */
     onSessionChange(agentType: string): void {
         this.lastSeenHashes.delete(agentType);
         this.lastSeenCounts.delete(agentType);
+        this.lastSeenSignatures.delete(agentType);
+        this.lastSeenTurnSignatures.delete(agentType);
     }
 
  /** Delete history files older than 30 days */
@@ -293,31 +533,42 @@ export function readChatHistory(
             .sort()
             .reverse();
 
- // Read lines from all files (reverse order)
         const allMessages: HistoryMessage[] = [];
-        const needed = offset + limit + 1; // hasMore check +1
+        const seen = new Set<string>();
 
         for (const file of files) {
-            if (allMessages.length >= needed) break;
             const filePath = path.join(dir, file);
             const content = fs.readFileSync(filePath, 'utf-8');
             const lines = content.trim().split('\n').filter(Boolean);
-            
- // Parse in reverse order
-            for (let i = lines.length - 1; i >= 0; i--) {
-                if (allMessages.length >= needed) break;
+
+            for (let i = 0; i < lines.length; i++) {
                 try {
-                    allMessages.push(JSON.parse(lines[i]));
+                    const parsed = JSON.parse(lines[i]) as HistoryMessage;
+                    const sanitizedMessage = sanitizeHistoryMessage(agentType, parsed);
+                    if (!sanitizedMessage) continue;
+                    const hash = buildHistoryMessageHash(agentType, sanitizedMessage);
+                    if (seen.has(hash)) continue;
+                    seen.add(hash);
+                    allMessages.push(sanitizedMessage);
                 } catch { /* skip invalid lines */ }
             }
         }
 
- // offset/limit apply
-        const sliced = allMessages.slice(offset, offset + limit);
-        const hasMore = allMessages.length > offset + limit;
+        allMessages.sort((a, b) => a.receivedAt - b.receivedAt);
+        const chronological: HistoryMessage[] = [];
+        let lastTurn: HistoryMessage | null = null;
+        for (const message of allMessages) {
+            const previous = chronological[chronological.length - 1];
+            if (isAdjacentHistoryDuplicate(agentType, previous, message)) continue;
+            if (message.role !== 'system' && isAdjacentHistoryDuplicate(agentType, lastTurn, message)) continue;
+            chronological.push(message);
+            if (message.role !== 'system') lastTurn = message;
+        }
+        const collapsed = collapseReplayAssistantTurns(agentType, chronological);
 
- // Sort in chronological order (top→bottom = oldest→newest)
-        sliced.reverse();
+ // offset/limit apply
+        const sliced = collapsed.slice(offset, offset + limit);
+        const hasMore = collapsed.length > offset + limit;
 
         return { messages: sliced, hasMore };
     } catch {