@adhdev/daemon-core 0.9.82-rc.374 → 0.9.82-rc.375

package/src/mesh/mesh-events-coordinator.ts

@@ -394,6 +394,42 @@ function isWeakTerminalLedgerPayload(payload: Record<string, unknown> | undefine
     return diag?.finalAssistantPresent === false || diag?.blockReason === 'missing_final_assistant';
 }
 
+// (FALSEIDLE-BGCHILD-b) A later genuine completion of the SAME task that carries a
+// substantively different — and fuller — final summary than the recorded terminal is the REAL
+// final that an earlier (false-idle) completion pre-empted, not a duplicate. The background-child
+// false idle is the nasty case the plain isWeakTerminalLedgerPayload supersession misses: the
+// early completion's screen parser DID see a prior/intermediate standard assistant, so it is
+// recorded as a STRONG terminal with a non-empty (but truncated) finalSummary. Without this the
+// providerSessionId/finalSummary dedup below swallows the genuine final and the coordinator is
+// stuck with the truncated mid-turn text forever (the one-shot-consumption symptom). Same-task,
+// new event is genuine, prior terminal summary is a strict prefix of (or otherwise shorter than)
+// the new one → treat as the corrected final and let it through. Conservative: requires the new
+// summary to be genuine evidence AND meaningfully longer, so an identical re-arrival or a SHORTER
+// later summary is still deduped.
+function supersedesTruncatedTerminalSummary(args: {
+    terminalPayload: Record<string, unknown>;
+    metadataEvent: Record<string, unknown>;
+    terminalTaskId: string;
+    eventTaskId: string;
+}): boolean {
+    // Only applies when both name the SAME task (a distinct task is handled by distinctTaskCompletion).
+    if (!args.terminalTaskId || !args.eventTaskId || args.terminalTaskId !== args.eventTaskId) return false;
+    if (!isGenuineCompletionEvidence(args.metadataEvent)) return false;
+    const terminalSummary = readNonEmptyString(args.terminalPayload.finalSummary);
+    const eventSummary = readNonEmptyString(args.metadataEvent.finalSummary);
+    if (!eventSummary) return false;
+    // Identical text → genuine duplicate, keep deduping.
+    if (terminalSummary === eventSummary) return false;
+    // The recorded terminal was a known-weak (false-idle) one → already handled by the weak
+    // supersession path; nothing extra to do here.
+    if (isWeakTerminalLedgerPayload(args.terminalPayload)) return false;
+    // No prior summary at all, or the new summary strictly extends / is meaningfully longer than
+    // the recorded one → the recorded terminal was the truncated pre-emption; supersede it.
+    if (!terminalSummary) return true;
+    if (eventSummary.startsWith(terminalSummary)) return true;
+    return eventSummary.length > terminalSummary.length + 32;
+}
+
 // The latest still-active direct-dispatch taskId for a session, resolved BEFORE the
 // completion flips the dispatch row terminal. Direct dispatches (mesh_send_task) have no
 // work-queue row, so this is the only taskId available to attribute the terminal ledger
@@ -1963,7 +1999,15 @@ function evaluateMeshEventSuppression(
             const terminalTaskId = readNonEmptyString(terminal.payload.taskId);
             const eventTaskId = readNonEmptyString(args.metadataEvent.taskId);
             const distinctTaskCompletion = !!eventTaskId && !!terminalTaskId && eventTaskId !== terminalTaskId;
-            if (!newDispatchAfterTerminal && !supersedesWeakTerminal && !distinctTaskCompletion) {
+            // (FALSEIDLE-BGCHILD-b) Same-task genuine completion carrying a fuller summary than the
+            // recorded (truncated, false-idle-pre-empted) terminal supersedes it — see helper.
+            const supersedesTruncatedTerminal = supersedesTruncatedTerminalSummary({
+                terminalPayload: terminal.payload,
+                metadataEvent: args.metadataEvent,
+                terminalTaskId,
+                eventTaskId,
+            });
+            if (!newDispatchAfterTerminal && !supersedesWeakTerminal && !distinctTaskCompletion && !supersedesTruncatedTerminal) {
                 const terminalProviderSessionId = readNonEmptyString(terminal.payload.providerSessionId);
                 const terminalFinalSummary = readNonEmptyString(terminal.payload.finalSummary);
                 const eventProviderSessionId = readNonEmptyString(args.metadataEvent.providerSessionId);

package/src/mesh/mesh-ledger.ts

@@ -44,6 +44,11 @@ export type MeshLedgerKind =
     | 'direct_dispatch_pruned'
     | 'event_held'
     | 'task_reclaimed'
+    // Gap2-A: a coordinator-recorded operating note — a runtime-accumulated
+    // lesson (provider quirk, pattern to avoid, recovery lesson) persisted in
+    // the ledger so it survives coordinator restarts and is provider-neutral.
+    // payload: { text, category?, createdAt?, sourceCoordinator? }
+    | 'coordinator_operating_note'
     ;
 
 export interface MeshLedgerEntry {

package/src/mesh/mesh-reconcile-loop.ts

@@ -205,6 +205,13 @@ function resolveCoordinatorSelfIds(mesh: LocalMeshEntry, drainDaemonIds: string[
     return [...ids];
 }
 
+// Observability: last-seen modal-park state per coordinator session, so we LOG.info
+// only on a TRANSITION (clear → parked, parked → cleared) instead of every 4s tick.
+// Per-process; a restart re-logs the first observation, which is desirable — it
+// re-confirms a coordinator that is still parked after the restart (the exact
+// "restart does not clear it" symptom the operator needs visibility into).
+const coordinatorModalParkState = new Map<string, boolean>();
+
 // Find live CLI coordinator instances on THIS daemon, keyed by mesh.
 function findLiveCoordinators(components: DaemonComponents): LiveCoordinator[] {
     const out: LiveCoordinator[] = [];
@@ -222,6 +229,20 @@ function findLiveCoordinators(components: DaemonComponents): LiveCoordinator[] {
         // and waiting_choice is absent from some of them (see cli-provider-instance).
         const modalParked = status === 'waiting_choice' || status === 'waiting_approval';
         const sessionId = readNonEmptyString(state.instanceId);
+        // Modal-park transition observability: a coordinator entering modal-park is what
+        // begins holding completion events under `modal_parked`; one leaving it is what
+        // drains them. Both transitions were previously SILENT (the operator had no log
+        // to diagnose a stuck/held completion), so emit a single line per edge.
+        const stateKey = `${meshId}::${sessionId || '?'}`;
+        const prevParked = coordinatorModalParkState.get(stateKey);
+        if (prevParked !== modalParked) {
+            coordinatorModalParkState.set(stateKey, modalParked);
+            if (modalParked) {
+                LOG.info('MeshReconcile', `Coordinator ${sessionId || '?'} (mesh ${meshId}) entered modal-park (status=${status}) — terminal events for it will be held until the modal is answered`);
+            } else if (prevParked === true) {
+                LOG.info('MeshReconcile', `Coordinator ${sessionId || '?'} (mesh ${meshId}) left modal-park (status=${status}) — held events will drain on this/next tick`);
+            }
+        }
         out.push({ meshId, instance: inst, sessionId, idle: status === 'idle', modalParked });
     }
     return out;
@@ -599,7 +620,73 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
         // force-injected via generatingCoordinators — we never block the deadlock-break.)
         if (targetCoordinators.length === 0) {
             if (modalParkedCoordinators.length > 0) {
-                LOG.info('MeshReconcile', `Reconcile skip → modal-parked: holding pending event(s) for mesh ${meshId} (${modalParkedCoordinators.length} coordinator(s) awaiting a modal answer; events left queued)`);
+                // ── orphan escape (MUST precede the blanket modal-park hold) ──────────
+                // A modal-parked coordinator with no idle/generating sibling otherwise
+                // wedges EVERY pending event under `modal_parked` until that modal resolves
+                // — including a STRICT-routed completion whose originating coordinator
+                // session is GONE (an orphan: the worktree/session that produced it was
+                // removed, or that coordinator session died). Such an event will never be
+                // deliverable to its target session no matter what the modal-parked sibling
+                // does, so holding it under modal_parked is a permanent-held leak (the very
+                // "data restart re-reproduces it" symptom — the gate is reconstructed live
+                // from the still-parked modal, so a restart does not clear it). Route those
+                // orphan events through the strict-route hold/expire path so the bounded
+                // STRICT_SESSION_MATCH_TTL eventually expires them (recoverable, ledgered)
+                // instead of leaving them held forever. A strict event whose target session
+                // IS live but merely modal-parked is left to the blanket hold below (it is
+                // genuinely transiently blocked, not orphaned).
+                const liveSessionIds = new Set(
+                    meshCoordinators.map(c => readNonEmptyString(c.sessionId)).filter(Boolean),
+                );
+                let orphanEscaped = 0;
+                const hasPendingForOrphanPeek = !store
+                    || (() => { try { return store.pendingEventCount(meshId) > 0; } catch { return true; } })();
+                if (hasPendingForOrphanPeek) {
+                    // Identify which pending event NAMES correspond to orphan-targeted events
+                    // (a strict targetCoordinatorSessionId that matches no live coordinator).
+                    let peeked: readonly PendingMeshCoordinatorEvent[] = [];
+                    try {
+                        peeked = getPendingMeshCoordinatorEvents(meshId, drainDaemonIds.length > 0 ? drainDaemonIds : undefined);
+                    } catch { peeked = []; }
+                    const isOrphan = (e: PendingMeshCoordinatorEvent): boolean => {
+                        const want = readNonEmptyString(e.targetCoordinatorSessionId);
+                        return !!want && !liveSessionIds.has(want);
+                    };
+                    const orphanEventNames = new Set(peeked.filter(isOrphan).map(e => e.event));
+                    if (orphanEventNames.size > 0) {
+                        // The drain filter is event-NAME scoped (not per-row), so draining by the
+                        // orphan event names also pulls any non-orphan event sharing that name. Drain
+                        // them all, then re-route: orphan-targeted events go through the strict-route
+                        // hold/expire path (bounded TTL → eventually ledger-expired, recoverable);
+                        // non-orphan events of the same name are re-queued unchanged (queuedAt
+                        // preserved) so they remain genuinely held for their still-live, modal-parked
+                        // target. This is the same per-event strict routing PHASE 2 does below — just
+                        // reached here because the blanket modal-park short-circuit would otherwise
+                        // wedge the orphans forever.
+                        let drained: PendingMeshCoordinatorEvent[] = [];
+                        try {
+                            drained = drainPendingMeshCoordinatorEvents(
+                                meshId,
+                                drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId,
+                                { onlyEvents: orphanEventNames },
+                            );
+                        } catch (e: any) {
+                            LOG.warn('MeshReconcile', `Orphan-escape drain failed for mesh ${meshId}: ${e?.message || e}`);
+                            drained = [];
+                        }
+                        for (const pending of drained) {
+                            if (isOrphan(pending)) {
+                                holdOrExpireStrictUnmatchedEvent(pending, readNonEmptyString(pending.targetCoordinatorSessionId), meshId);
+                                orphanEscaped++;
+                            } else {
+                                // Still-live (modal-parked) target — re-queue unchanged so it is held
+                                // for the next modal-resolved tick, exactly like the blanket hold would.
+                                try { queuePendingMeshCoordinatorEvent(pending); } catch { /* best-effort re-queue */ }
+                            }
+                        }
+                    }
+                }
+                LOG.info('MeshReconcile', `Reconcile skip → modal-parked: holding pending event(s) for mesh ${meshId} (${modalParkedCoordinators.length} coordinator(s) awaiting a modal answer; events left queued${orphanEscaped > 0 ? `; ${orphanEscaped} orphan-targeted event(s) routed to strict-route TTL` : ''})`);
                 // C1: mirror held terminal events into the ledger so a held completion's
                 // worker summary is auditable/recoverable even if the modal is never
                 // resolved, the coordinator restarts, or the pending file is later trimmed.
@@ -1034,6 +1121,32 @@ async function reconcileUnterminatedDirectDispatches(
         const evidence = extractFinalAssistantSummaryEvidence(messages);
         if (!evidence.finalSummary) continue; // no assistant result yet — nothing to attribute
 
+        // STALE-SUMMARY guard (modal-parked / reused-session misattribution): a direct
+        // dispatch frequently reuses a session that already ran a PRIOR task. read_chat
+        // returns the tail of the WHOLE session, so extractFinalAssistantSummaryEvidence
+        // picks the latest user-facing assistant message — which, for a task that has
+        // barely started (the session momentarily reads idle between turns), is the prior
+        // task's final summary. The downstream reconcile proves the summary is after the
+        // LEDGER task_dispatched entry; here we additionally have the AUTHORITATIVE per-task
+        // dispatchedAt (the dispatch-store row, immune to ledger-ordering quirks), so when
+        // the selected transcript message is provably BEFORE this task's own dispatch we
+        // refuse it outright — it is a prior task's summary, not this task's output (the
+        // 2843ms-duration stale-summary bug where task 2e3f501e copy-pasted 4eca2d9d's
+        // summary). When the message carries no usable timestamp we do NOT block here: the
+        // downstream reconcile already rejects a non-JSON summary it cannot prove is
+        // post-dispatch (transcript_not_proven_after_dispatch), and a structured
+        // final_summary_json is self-attributing — so a timeless provider is not
+        // over-blocked while the provable-stale case is still caught.
+        const dispatchedAtMs = Date.parse(readNonEmptyString(dispatch.dispatchedAt));
+        const transcriptAtMs = Date.parse(evidence.transcriptMessageAt ?? '');
+        if (Number.isFinite(dispatchedAtMs) && Number.isFinite(transcriptAtMs) && transcriptAtMs < dispatchedAtMs) {
+            LOG.info('MeshReconcile', `Stale-summary guard: skipping transcript reconcile for task ${taskId} on node ${nodeId} (mesh ${mesh.id}) — final assistant message (${evidence.transcriptMessageAt}) predates this task's dispatch (${dispatch.dispatchedAt}); it is a prior task's summary`);
+            traceMeshEventDrop('reconcile_stale_summary_before_dispatch', {
+                taskId, sessionId, nodeId, meshId: mesh.id, event: 'agent:generating_completed',
+            }, `transcriptAt=${evidence.transcriptMessageAt} < dispatchedAt=${dispatch.dispatchedAt}`);
+            continue;
+        }
+
         const providerSessionId = readNonEmptyString(payload.providerSessionId);
         const coordinatorDaemonId = selfIds.find(id => !!id);
         try {

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

@@ -102,6 +102,24 @@ type ExternalTranscriptProbe = {
 
 const COMPLETED_FINALIZATION_RETRY_MS = 1000;
 const COMPLETED_FINALIZATION_MAX_WAIT_MS = 30_000;
+// (FALSEIDLE-BGCHILD-a) Minimum generating→idle settle window for native-history mesh worker
+// sessions. Native-history providers (e.g. claude-cli) normally flush the completion with
+// flushDelay=0 — the transcript is authoritative, so there is no reason to wait. But a worker
+// turn that spawns a BACKGROUND child (e.g. `npm test &`, a backgrounded Bash tool) can paint
+// a burst of child output, fall quiet, and have the screen parser read a PRIOR/intermediate
+// standard assistant as if the turn were done — firing a false idle while the agent is in fact
+// still generating (e.g. mid-commit). With flushDelay=0 there is no window for the resume guard
+// in flushCompletedDebounceIfFinalized (latestVisibleStatus !== 'idle' → cancel) to observe the
+// agent picking the turn back up. A short non-zero settle window restores that resume guard for
+// mesh workers without delaying genuinely-finished turns beyond this bound. Scoped to mesh
+// worker sessions so interactive native-history sessions keep the immediate flush.
+const NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 1500;
+// TASKBUBBLE-DUP: window during which an identical user-input ack (same trimmed
+// content on the same instance) is treated as a redelivery of one dispatch and
+// suppressed from the chat transcript. Matches the coordinator-side
+// DUPLICATE_DISPATCH_WINDOW_MS (mesh-tools) so the daemon's bubble-level guard
+// covers the same retry horizon as the MCP-level dispatch dedup.
+const USER_INPUT_ACK_DEDUP_WINDOW_MS = 60_000;
 
 /** Events that signal a dispatched mesh task has reached a terminal state.
  *  Detach the mesh assignment after emitting one of these so the worker's
@@ -431,6 +449,14 @@ export class CliProviderInstance implements ProviderInstance {
     private runtimeMessages: Array<{ key: string; message: ChatMessage }> = [];
     private lastPersistedHistoryMessages: PersistableCliHistoryMessage[] = [];
     private lastAcknowledgedUserInputAt = 0;
+    // TASKBUBBLE-DUP: per-content last-ack timestamps so the same dispatched
+    // prompt acked twice in quick succession (the worker buffers the first
+    // send during bootstrap/busy, then a redelivery — dispatch-confirm-timeout
+    // requeue or a reconcile re-dispatch — fires a SECOND send_chat before the
+    // outbound queue drains) collapses to ONE user bubble. Keyed on the trimmed
+    // content; an entry older than USER_INPUT_ACK_DEDUP_WINDOW_MS is treated as
+    // a fresh, intentional resend and is NOT suppressed.
+    private recentUserInputAcks = new Map<string, number>();
     private lastNativeSourceCanonicalCheckAt = 0;
     private lastNativeSourceCanonicalCacheKey: string | undefined = undefined;
     private cachedSqliteDb: {
@@ -1056,7 +1082,31 @@ export class CliProviderInstance implements ProviderInstance {
         if (!content) return;
 
         const receivedAt = Date.now();
+
+        // TASKBUBBLE-DUP: collapse a redelivered dispatch to one bubble. A single
+        // mesh_send_task can reach this instance as TWO send_chat calls when the
+        // first injection is buffered during bootstrap/busy and a retry (dispatch-
+        // confirm-timeout requeue, or a reconcile re-dispatch) fires before the
+        // outbound queue drains. The previous dedupKey hashed receivedAt, so the
+        // two acks produced different keys and BOTH bubbled. Suppress an identical
+        // content ack seen within USER_INPUT_ACK_DEDUP_WINDOW_MS; a later resend of
+        // the same text (beyond the window) is a genuine new turn and still shows.
+        const ackContentKey = shortHash(`${this.instanceId}:${content}`, 24);
+        const lastAckAt = this.recentUserInputAcks.get(ackContentKey);
+        if (lastAckAt !== undefined && receivedAt - lastAckAt <= USER_INPUT_ACK_DEDUP_WINDOW_MS) {
+            // Refresh the timestamp so a steady stream of redeliveries keeps
+            // collapsing, and prune stale entries to bound the map size.
+            this.recentUserInputAcks.set(ackContentKey, receivedAt);
+            this.pruneRecentUserInputAcks(receivedAt);
+            return;
+        }
+        this.recentUserInputAcks.set(ackContentKey, receivedAt);
+        this.pruneRecentUserInputAcks(receivedAt);
+
         this.lastAcknowledgedUserInputAt = receivedAt;
+        // The runtimeMessages dedupKey stays per-call unique (includes receivedAt)
+        // so a genuine resend of the same text after the window appends a fresh
+        // bubble; redelivery within the window is already suppressed above.
         const dedupKey = `user_input_ack:${shortHash(`${this.instanceId}:${content}:${receivedAt}`, 24)}`;
         this.appendRuntimeMessage(buildChatMessage({
             role: 'user',
@@ -1074,6 +1124,14 @@ export class CliProviderInstance implements ProviderInstance {
         } as ChatMessage), dedupKey);
     }
 
+    /** Drop user-input ack entries older than the dedup window so the map can't grow unbounded. */
+    private pruneRecentUserInputAcks(now: number): void {
+        if (this.recentUserInputAcks.size <= 1) return;
+        for (const [key, at] of this.recentUserInputAcks) {
+            if (now - at > USER_INPUT_ACK_DEDUP_WINDOW_MS) this.recentUserInputAcks.delete(key);
+        }
+    }
+
     dispose(): void {
         this.adapter.shutdown();
         this.monitor.reset();
@@ -2004,8 +2062,17 @@ export class CliProviderInstance implements ProviderInstance {
                         previousStatus: this.lastStatus,
                     };
                     const ownsExternalHistory = !!(this.adapter as any)?.chatMessagesOwnedExternally;
-                    const flushDelay = ownsExternalHistory ? 0 : 3000;
-                    LOG.debug('CLI', `[${this.type}] set completedDebouncePending duration=${duration}s ownsExternalHistory=${ownsExternalHistory} flushDelay=${flushDelay}ms generatingStartedAt=${this.generatingStartedAt}`);
+                    // (FALSEIDLE-BGCHILD-a) Native-history providers flush immediately (the
+                    // transcript is authoritative). For mesh worker sessions, give the
+                    // generating→idle transition a short settle window so a background-child
+                    // false idle (quiet after a backgrounded test/command while the parent turn
+                    // continues) gets caught by the resume guard in flushCompletedDebounceIfFinalized
+                    // instead of firing an early completion the coordinator can never correct.
+                    const meshWorkerSession = this.isMeshWorkerSession();
+                    const flushDelay = ownsExternalHistory
+                        ? (meshWorkerSession ? NATIVE_HISTORY_MESH_IDLE_SETTLE_MS : 0)
+                        : 3000;
+                    LOG.debug('CLI', `[${this.type}] set completedDebouncePending duration=${duration}s ownsExternalHistory=${ownsExternalHistory} meshWorker=${meshWorkerSession} flushDelay=${flushDelay}ms generatingStartedAt=${this.generatingStartedAt}`);
                     this.scheduleCompletedDebounceFlush(flushDelay);
                 }
             } else if (newStatus === 'idle' && this.lastStatus === 'starting') {