@adhdev/daemon-core 0.8.27 → 0.8.29

package/src/commands/cli-manager.ts

@@ -522,10 +522,10 @@ export class DaemonCliManager {
         if (!cliInfo) {
             const installHint = provider?.install || '';
             const displayName = provider?.displayName || provider?.name || cliType;
-            const spawnCmd = provider?.spawn?.command || cliType;
+            const spawnCmd = this.providerLoader.getSpawnCommand(normalizedType, provider?.spawn?.command || cliType);
             throw new Error(
                 `${displayName} is not installed.\n` +
-                `Command '${spawnCmd}' not found on PATH.\n` +
+                `Command '${spawnCmd}' is not available.\n` +
                 (installHint ? `\n${installHint}\n` : '') +
                 `\nRun 'adhdev doctor' for detailed diagnostics.`
             );
@@ -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/handler.ts

@@ -44,6 +44,7 @@ export interface CommandContext {
     /** ProviderInstanceManager — for runtime settings propagation */
     instanceManager?: ProviderInstanceManager;
     sessionRegistry?: SessionRegistry;
+    onProviderSettingChanged?: (providerType: string, key: string, value: any) => Promise<void> | void;
 }
 
 /**

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 : '';
@@ -365,6 +376,11 @@ export class DaemonCommandRouter {
                 if (!ideType) throw new Error('ideType required');
                 const killProcess = args?.killProcess !== false; // default true
                 await this.stopIde(ideType, killProcess);
+                try {
+                    const results = await detectIDEs(this.deps.providerLoader);
+                    this.deps.detectedIdes.value = results;
+                    this.deps.providerLoader.setIdeDetectionResults(results, true);
+                } catch { /* ignore detection refresh errors */ }
                 return { success: true, ideType, stopped: true, processKilled: killProcess };
             }
 
@@ -415,6 +431,11 @@ export class DaemonCommandRouter {
                     }
                 }
                 this.deps.onIdeConnected?.();
+                try {
+                    const results = await detectIDEs(this.deps.providerLoader);
+                    this.deps.detectedIdes.value = results;
+                    this.deps.providerLoader.setIdeDetectionResults(results, true);
+                } catch { /* ignore detection refresh errors */ }
                 if (result.success && resolvedWorkspace) {
                     try {
                         const next = appendRecentActivity(loadState(), {
@@ -441,8 +462,9 @@ export class DaemonCommandRouter {
 
             // ─── Detect IDEs ───
             case 'detect_ides': {
-                const results = await detectIDEs();
+                const results = await detectIDEs(this.deps.providerLoader);
                 this.deps.detectedIdes.value = results;
+                this.deps.providerLoader.setIdeDetectionResults(results, true);
                 return { success: true, detectedInfo: results };
             }
 

package/src/commands/stream-commands.ts

@@ -76,7 +76,7 @@ export function handleGetProviderSettings(h: CommandHelpers, args: any): Command
     return { success: true, settings: allSettings, values: allValues };
 }
 
-export function handleSetProviderSetting(h: CommandHelpers, args: any): CommandResult {
+export async function handleSetProviderSetting(h: CommandHelpers, args: any): Promise<CommandResult> {
     const loader = h.ctx.providerLoader as ProviderLoader | undefined;
     const { providerType, key, value } = args || {};
     if (!providerType || !key || value === undefined) {
@@ -89,6 +89,7 @@ export function handleSetProviderSetting(h: CommandHelpers, args: any): CommandR
             const updated = h.ctx.instanceManager.updateInstanceSettings(providerType, allSettings);
             LOG.info('Command', `[set_provider_setting] ${providerType}.${key}=${JSON.stringify(value)} → ${updated} instance(s) updated`);
         }
+        await h.ctx.onProviderSettingChanged?.(providerType, key, value);
         return { success: true, providerType, key, value };
     }
     return { success: false, error: `Failed to set ${providerType}.${key} — invalid key, value, or not a public setting` };
@@ -133,7 +134,7 @@ function getCliScriptCommand(payload: any): { type: string; text?: string } | nu
 
     const command = payload.command;
     if (!command || typeof command !== 'object') return null;
-    if (command.type !== 'send_message') return null;
+    if (command.type !== 'send_message' && command.type !== 'pty_write') return null;
 
     const text = typeof command.text === 'string'
         ? command.text.trim()
@@ -141,7 +142,7 @@ function getCliScriptCommand(payload: any): { type: string; text?: string } | nu
             ? command.message.trim()
             : '';
     if (!text) return null;
-    return { type: 'send_message', text };
+    return { type: command.type, text };
 }
 
 function applyProviderPatch(h: CommandHelpers, args: any, payload: any): void {
@@ -191,6 +192,8 @@ async function executeProviderScript(h: CommandHelpers, args: any, scriptName: s
             const cliCommand = getCliScriptCommand(parsed.payload);
             if (cliCommand?.type === 'send_message' && cliCommand.text) {
                 await adapter.sendMessage(cliCommand.text);
+            } else if (cliCommand?.type === 'pty_write' && cliCommand.text && adapter.writeRaw) {
+                adapter.writeRaw(cliCommand.text + '\r');
             }
             applyProviderPatch(h, args, parsed.payload);
             return { success: true, ...(parsed.payload && typeof parsed.payload === 'object' ? parsed.payload : { result: parsed.payload }) };

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 {