@adhdev/daemon-core 0.9.82-rc.133 → 0.9.82-rc.134

package/package.json

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

package/src/mesh/mesh-events.ts

@@ -415,22 +415,38 @@ function findRecentTerminalLedgerEvidence(args: {
     meshId: string;
     sessionId?: string;
     nodeId?: string;
-}): { kind: MeshLedgerKind; payload: Record<string, unknown>; timestamp: string } | null {
+}): { id: string; kind: MeshLedgerKind; payload: Record<string, unknown>; timestamp: string } | null {
     if (!args.sessionId && !args.nodeId) return null;
     const entries = readLedgerEntries(args.meshId);
     for (let i = entries.length - 1; i >= 0; i--) {
         const entry = entries[i];
         if (entry.kind !== 'task_completed' && entry.kind !== 'task_failed' && entry.kind !== 'task_stalled') continue;
         if (args.sessionId && entry.sessionId === args.sessionId) {
-            return { kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
+            return { id: entry.id, kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
         }
         if (!args.sessionId && args.nodeId && entry.nodeId === args.nodeId) {
-            return { kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
+            return { id: entry.id, kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
         }
     }
     return null;
 }
 
+// Returns true when a task_dispatched entry for the given session appears AFTER the terminal
+// entry (identified by terminalId) in ledger order. Positional (append) order is used rather
+// than timestamp comparison because both entries may share the same millisecond.
+function hasDispatchAfterTerminal(meshId: string, sessionId: string, terminalId: string): boolean {
+    const entries = readLedgerEntries(meshId);
+    let pastTerminal = false;
+    for (const entry of entries) {
+        if (!pastTerminal) {
+            if (entry.id === terminalId) pastTerminal = true;
+            continue;
+        }
+        if (entry.kind === 'task_dispatched' && entry.sessionId === sessionId) return true;
+    }
+    return false;
+}
+
 function buildLongGeneratingCompletionReconciliation(args: {
     meshId: string;
     nodeId?: string;
@@ -1060,17 +1076,22 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             nodeId: eventNodeId || undefined,
         });
         if (terminal?.kind === 'task_completed' && !sessionHasActiveAssignment(args.meshId, eventSessionId)) {
-            const terminalProviderSessionId = readNonEmptyString(terminal.payload.providerSessionId);
-            const terminalFinalSummary = readNonEmptyString(terminal.payload.finalSummary);
-            const eventProviderSessionId = readNonEmptyString(args.metadataEvent.providerSessionId);
-            const eventFinalSummary = readNonEmptyString(args.metadataEvent.finalSummary);
-            if (
-                (terminalProviderSessionId && terminalProviderSessionId === eventProviderSessionId)
-                || (terminalFinalSummary && terminalFinalSummary === eventFinalSummary)
-                || args.metadataEvent.source === 'long_generating_reconciliation'
-            ) {
-                LOG.info('MeshEvents', `Suppressed duplicate completion with existing terminal ledger evidence for mesh ${args.meshId} session ${eventSessionId}`);
-                return { success: true, forwarded: 0, suppressed: true, duplicateCompletion: true, terminalLedgerEvidence: true };
+            // If a new task_dispatched was recorded for this session after the prior terminal,
+            // this completion belongs to the new task — never suppress it as a duplicate.
+            const newDispatchAfterTerminal = hasDispatchAfterTerminal(args.meshId, eventSessionId, terminal.id);
+            if (!newDispatchAfterTerminal) {
+                const terminalProviderSessionId = readNonEmptyString(terminal.payload.providerSessionId);
+                const terminalFinalSummary = readNonEmptyString(terminal.payload.finalSummary);
+                const eventProviderSessionId = readNonEmptyString(args.metadataEvent.providerSessionId);
+                const eventFinalSummary = readNonEmptyString(args.metadataEvent.finalSummary);
+                if (
+                    (terminalProviderSessionId && terminalProviderSessionId === eventProviderSessionId)
+                    || (terminalFinalSummary && terminalFinalSummary === eventFinalSummary)
+                    || args.metadataEvent.source === 'long_generating_reconciliation'
+                ) {
+                    LOG.info('MeshEvents', `Suppressed duplicate completion with existing terminal ledger evidence for mesh ${args.meshId} session ${eventSessionId}`);
+                    return { success: true, forwarded: 0, suppressed: true, duplicateCompletion: true, terminalLedgerEvidence: true };
+                }
             }
         }
         const duplicateCompletion = isDuplicateMeshCompletionEvent({

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

@@ -899,7 +899,16 @@ export class CliProviderInstance implements ProviderInstance {
         if (!isCliGeneratingLikeStatus(parsedRawStatus)) return false;
         if (adapterRawStatus !== 'idle') return false;
         if (hasNonEmptyCliModalButtons(parsedStatus?.activeModal ?? parsedStatus?.modal)) return false;
-        return !this.hasAdapterPendingResponse();
+        if (this.hasAdapterPendingResponse()) return false;
+        // Do not suppress when the adapter's raw response buffer is still non-empty.
+        // This catches the case where isWaitingForResponse has already flipped to false
+        // (so getPartialResponse() returns '') but the provider's native parser still
+        // reports generating because it's parsing buffered content. Suppressing the
+        // finalization block here would emit a false completion event while the provider
+        // session is still actively processing its response stream.
+        const adapterAny = this.adapter as any;
+        if (typeof adapterAny?.responseBuffer === 'string' && adapterAny.responseBuffer.trim()) return false;
+        return true;
     }
 
     private getCompletedFinalizationBlock(latestVisibleStatus: string): CompletedFinalizationBlock | null {
@@ -1122,12 +1131,30 @@ export class CliProviderInstance implements ProviderInstance {
                 }
             } else if (newStatus === 'idle' && (this.lastStatus === 'generating' || this.lastStatus === 'waiting_approval')) {
                 const duration = this.generatingStartedAt ? Math.round((now - this.generatingStartedAt) / 1000) : 0;
-                // If debounce still pending (generating lasted < 1s), cancel both events
+                // If debounce still pending (generating lasted < 1s), cancel both UI events.
+                // Still emit agent:generating_completed so mesh orchestration can record
+                // task_completed for direct dispatches that complete faster than the debounce.
                 if (this.generatingDebouncePending) {
-                    LOG.info('CLI', `[${this.type}] suppressed short generating (${now - this.generatingStartedAt}ms)`);
+                    const shortDurationMs = this.generatingStartedAt ? now - this.generatingStartedAt : 0;
+                    LOG.info('CLI', `[${this.type}] suppressed short generating (${shortDurationMs}ms)`);
                     if (this.generatingDebounceTimer) { clearTimeout(this.generatingDebounceTimer); this.generatingDebounceTimer = null; }
                     this.generatingDebouncePending = null;
                     this.generatingStartedAt = 0;
+                    // Emit completion for mesh task association even though the UI generating
+                    // started/completed pair is suppressed (too short for visible UI update).
+                    let shortFinalSummary: string | undefined;
+                    try { shortFinalSummary = extractFinalSummaryFromMessages(this.adapter?.getScriptParsedStatus()?.messages); } catch { /* best-effort */ }
+                    this.pushEvent({
+                        event: 'agent:generating_completed',
+                        chatTitle,
+                        duration: 0,
+                        timestamp: now,
+                        finalSummary: shortFinalSummary,
+                        completionDiagnostic: {
+                            reason: 'short_generating_suppressed',
+                            shortDurationMs,
+                        },
+                    });
                 } else {
                     // Debounce completed, then require the rich transcript path that read_chat
                     // uses to show an idle turn whose last user-facing message is assistant.