@adhdev/daemon-core 0.9.82-rc.128 → 0.9.82-rc.129

package/dist/providers/cli-provider-instance.d.ts

@@ -97,6 +97,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     getSessionModalState(): SessionModalState;
     updateSettings(newSettings: Record<string, any>): void;
     onEvent(event: string, data?: any): void;
+    recordAcknowledgedUserInput(input: InputEnvelope | string): void;
     dispose(): void;
     private completedDebounceTimer;
     private completedDebouncePending;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.128",
+  "version": "0.9.82-rc.129",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/commands/chat-commands.ts

@@ -14,7 +14,7 @@ import { assertProviderSupportsDeclaredInput, assertTextOnlyInput } from '../pro
 import { validateReadChatResultPayload } from '../providers/read-chat-contract.js';
 import { pickApprovalButton } from '../providers/approval-utils.js';
 import type { ProviderInstance } from '../providers/provider-instance.js';
-import { isNativeSourceCanonicalHistory, readProviderChatHistory } from '../config/chat-history.js';
+import { isNativeSourceCanonicalHistory, readChatHistory, readProviderChatHistory } from '../config/chat-history.js';
 import { LOG, getRecentLogs } from '../logging/logger.js';
 import { getRecentDebugTrace, recordDebugTrace } from '../logging/debug-trace.js';
 import { buildChatMessageSignature, hashSignatureParts } from '../chat/chat-signatures.js';
@@ -40,6 +40,7 @@ interface ApprovalSelectableInstance extends ProviderInstance {
 
 interface RuntimeChatMessageMerger extends ProviderInstance {
     mergeRuntimeChatMessages?(messages: ChatMessage[]): ChatMessage[];
+    recordAcknowledgedUserInput?(input: InputEnvelope | string): void;
 }
 
 type LegacyStringScript = (params?: Record<string, unknown> | string) => string;
@@ -454,6 +455,45 @@ function coerceUnsafeNativeFallbackStatus(status: string, activeModal: unknown):
     return 'idle';
 }
 
+function isRuntimeInputAckMessage(message: ChatMessage | undefined): boolean {
+    if (!message || typeof message !== 'object') return false;
+    const role = String((message as any).role || '').trim().toLowerCase();
+    if (role !== 'user' && role !== 'human') return false;
+    const meta = (message as any).meta;
+    return !!meta && typeof meta === 'object' && !Array.isArray(meta) && meta.runtimeInputAck === true;
+}
+
+function selectRuntimeInputAckMessages(messages: ChatMessage[]): ChatMessage[] {
+    return messages.filter((message) => isRuntimeInputAckMessage(message));
+}
+
+function readExactRuntimeMirrorMessages(args: {
+    providerType: string;
+    targetSessionId?: string;
+    currentSessionId?: string;
+    tailLimit: number;
+    historyBehavior?: ProviderModule['historyBehavior'];
+}): ChatMessage[] {
+    const targetSessionId = String(args.targetSessionId || '').trim();
+    const currentSessionId = String(args.currentSessionId || '').trim();
+    if (!targetSessionId || targetSessionId !== currentSessionId) return [];
+
+    const history = readChatHistory(
+        args.providerType,
+        0,
+        Math.max(args.tailLimit || 0, 200),
+        targetSessionId,
+        0,
+        args.historyBehavior,
+    );
+    return normalizeChatMessages((history.messages || []) as ChatMessage[])
+        .filter((message) => {
+            const historySessionId = String((message as any).historySessionId || '').trim();
+            const instanceId = String((message as any).instanceId || '').trim();
+            return historySessionId === targetSessionId || instanceId === targetSessionId;
+        });
+}
+
 function supportsCliNativeTranscript(providerType: string, provider?: ProviderModule): boolean {
     if (CLI_NATIVE_TRANSCRIPT_PROVIDERS.has(providerType)) return true;
     return provider?.category === 'cli' && isNativeSourceCanonicalHistory(provider?.canonicalHistory);
@@ -1512,10 +1552,26 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                         });
                         const unsafeNativeFallback = adapter.cliType === 'codex-cli'
                             && isUnsafeNativeTranscriptFallback(fallbackReason);
+                        const safeRuntimeAckMessages = unsafeNativeFallback
+                            ? selectRuntimeInputAckMessages(returnedMessages)
+                            : [];
+                        const exactRuntimeMirrorMessages = unsafeNativeFallback
+                            && safeRuntimeAckMessages.length === 0
+                            ? readExactRuntimeMirrorMessages({
+                                providerType,
+                                targetSessionId: typeof args?.targetSessionId === 'string' ? args.targetSessionId : undefined,
+                                currentSessionId: typeof (h.currentSession as any)?.sessionId === 'string' ? (h.currentSession as any).sessionId : undefined,
+                                tailLimit: nativeHistoryLimit,
+                                historyBehavior: provider?.historyBehavior,
+                            })
+                            : [];
+                        const safeDaemonMessages = safeRuntimeAckMessages.length > 0
+                            ? safeRuntimeAckMessages
+                            : exactRuntimeMirrorMessages;
                         if (unsafeNativeFallback) {
-                            selectedMessages = [];
-                            selectedTranscriptAuthority = undefined;
-                            selectedCoverage = undefined;
+                            selectedMessages = safeDaemonMessages;
+                            selectedTranscriptAuthority = safeDaemonMessages.length > 0 ? 'daemon' : undefined;
+                            selectedCoverage = safeDaemonMessages.length > 0 ? 'tail' : undefined;
                             selectedStatus = coerceUnsafeNativeFallbackStatus(returnedStatus, activeModal);
                         }
                         messageSource = buildCliMessageSourceProvenance({
@@ -1534,11 +1590,15 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                             unavailableReason,
                             nativeMessages,
                             ptyMessages: returnedMessages,
-                            returnedMessages: unsafeNativeFallback ? [] : returnedMessages,
+                            returnedMessages: unsafeNativeFallback ? safeDaemonMessages : returnedMessages,
                             safeMapping,
                             freshEnough,
                             ptyStatusApprovalOnly: unsafeNativeFallback,
                         });
+                        if (unsafeNativeFallback && exactRuntimeMirrorMessages.length > 0) {
+                            (messageSource as any).selectedDaemonSource = 'exact-runtime-mirror';
+                            (messageSource as any).transcriptAuthority = 'daemon';
+                        }
                     }
                 }
             }
@@ -1954,6 +2014,12 @@ export async function handleSendChat(h: CommandHelpers, args: any): Promise<Comm
                 } else {
                     await adapter.sendMessage(text);
                 }
+                const target = getTargetInstance(h, args) as RuntimeChatMessageMerger | null;
+                if (target?.category === 'cli'
+                    && target.type === adapter.cliType
+                    && typeof target.recordAcknowledgedUserInput === 'function') {
+                    target.recordAcknowledgedUserInput(input);
+                }
                 return {
                     ..._logSendSuccess(`${transport}-adapter`, adapter.cliType),
                     ...(forceSend ? { forceSent: true } : {}),

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

@@ -752,6 +752,34 @@ export class CliProviderInstance implements ProviderInstance {
         }
     }
 
+    recordAcknowledgedUserInput(input: InputEnvelope | string): void {
+        const content = typeof input === 'string'
+            ? input.trim()
+            : buildCliStructuredInputPrompt(input).trim();
+        if (!content) return;
+
+        const receivedAt = Date.now();
+        const dedupKey = `user_input_ack:${crypto
+            .createHash('sha256')
+            .update(`${this.instanceId}:${content}:${receivedAt}`)
+            .digest('hex')
+            .slice(0, 24)}`;
+        this.appendRuntimeMessage(buildChatMessage({
+            role: 'user',
+            senderName: 'User',
+            kind: 'standard',
+            content,
+            receivedAt,
+            timestamp: receivedAt,
+            source: 'runtime_input_ack',
+            meta: {
+                runtimeInputAck: true,
+                provider: this.type,
+                workspace: this.workingDir,
+            },
+        } as ChatMessage), dedupKey);
+    }
+
     dispose(): void {
         this.adapter.shutdown();
         this.monitor.reset();
@@ -1450,12 +1478,28 @@ export class CliProviderInstance implements ProviderInstance {
             index,
             source: 'parsed',
         }));
+        const getRole = (message: ChatMessage): string => typeof message.role === 'string'
+            ? message.role.trim().toLowerCase()
+            : '';
         const runtimeEntries: MergeEntry[] = this.runtimeMessages.map((entry, index) => ({
             message: entry.message,
             index: parsedMessages.length + index,
-            source: 'runtime',
+            source: 'runtime' as const,
             runtimeKey: entry.key,
-        }));
+        })).filter((entry) => {
+            const meta = entry.message.meta && typeof entry.message.meta === 'object' && !Array.isArray(entry.message.meta)
+                ? entry.message.meta as Record<string, unknown>
+                : {};
+            if (meta.runtimeInputAck !== true) return true;
+            const runtimeText = flattenContent(entry.message.content).replace(/\s+/g, ' ').trim();
+            if (!runtimeText) return false;
+            return !parsedEntries.some((parsedEntry) => {
+                const parsedRole = getRole(parsedEntry.message);
+                if (parsedRole !== 'user' && parsedRole !== 'human') return false;
+                const parsedText = flattenContent(parsedEntry.message.content).replace(/\s+/g, ' ').trim();
+                return parsedText === runtimeText;
+            });
+        });
         const getTime = (message: ChatMessage): number => {
             const value = typeof message.receivedAt === 'number'
                 ? message.receivedAt
@@ -1465,9 +1509,6 @@ export class CliProviderInstance implements ProviderInstance {
             return Number.isFinite(value) && value > 0 ? value : 0;
         };
 
-        const getRole = (message: ChatMessage): string => typeof message.role === 'string'
-            ? message.role.trim().toLowerCase()
-            : '';
         const isRuntimeOverlay = (entry: MergeEntry): boolean => {
             if (entry.source !== 'runtime') return false;
             const key = typeof entry.runtimeKey === 'string' ? entry.runtimeKey.trim().toLowerCase() : '';