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

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

@@ -4,7 +4,7 @@ import { randomUUID } from 'crypto';
 import { LOG } from '../logging/logger.js';
 import { getLedgerDir, readLedgerEntries, appendLedgerEntry } from './mesh-ledger.js';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-import { buildMeshSystemMessage, readNonEmptyString, readRecord, resolveEventSessionId, readMeshCompletionSummary } from './mesh-events-utils.js';
+import { buildMeshSystemMessage, readNonEmptyString, readRecord, resolveEventSessionId, readMeshCompletionSummary, isWeakCompletionMetadata } from './mesh-events-utils.js';
 import { expandDaemonIdForms } from '@adhdev/mesh-shared';
 
 // ---------------------------------------------------------------------------
@@ -99,14 +99,6 @@ function hasPendingRefineTerminalEventDuplicate(event: PendingMeshCoordinatorEve
 // swallowed by the earlier weak one.
 const TERMINAL_COMPLETION_EVENTS = new Set(['agent:generating_completed', 'agent:stopped']);
 
-function isWeakCompletionMetadata(metadata: Record<string, unknown>): boolean {
-    const evidenceLevel = readNonEmptyString(metadata.evidenceLevel);
-    if (evidenceLevel === 'insufficient' || evidenceLevel === 'weak') return true;
-    if (metadata.reviewRecommended === true) return true;
-    const diag = readRecord(metadata.completionDiagnostic);
-    return diag?.finalAssistantPresent === false || diag?.blockReason === 'missing_final_assistant';
-}
-
 export function buildPendingEventFingerprint(event: PendingMeshCoordinatorEvent): string {
     const metadata = readRecord(event.metadataEvent) || {};
     // Bootstrap events are node-scoped: dedup by meshId+event+nodeId only.
@@ -150,7 +142,6 @@ export function buildPendingEventFingerprint(event: PendingMeshCoordinatorEvent)
 // wasDirectDeliveredToCoordinator) was removed when spontaneous PTY direct-inject was retired.
 // Delivery is now queue-drain-only: an event is consumed by exactly one drainer via the atomic
 // SQLite drained=1 marking, so there is no PTY-vs-poll double-delivery left to dedup against.
-// The dormant mesh_direct_delivered_events table / store helpers remain (harmless) but unused.
 
 export function hasPendingCoordinatorEventDuplicate(event: PendingMeshCoordinatorEvent): boolean {
     const fingerprint = buildPendingEventFingerprint(event);

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

@@ -3,7 +3,7 @@ import type { MeshLedgerKind } from './mesh-ledger.js';
 import { updateDirectDispatchStatus, cleanupTerminalDirectDispatches } from './mesh-work-queue.js';
 import { markSessionDeliveriesTerminal } from './mesh-delivery-policy.js';
 import { queuePendingMeshCoordinatorEvent } from './mesh-events-pending.js';
-import { readNonEmptyString, readRecord, resolveEventSessionId, readWorkerResultMetadata } from './mesh-events-utils.js';
+import { readNonEmptyString, readRecord, resolveEventSessionId, readWorkerResultMetadata, isWeakCompletionEvidence } from './mesh-events-utils.js';
 import { meshNodeIdMatches, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 
 // ---------------------------------------------------------------------------
@@ -74,17 +74,6 @@ export function hasUnterminalDirectDispatchLedgerEntry(meshId: string, sessionId
     return false;
 }
 
-// True when a terminal ledger payload was recorded from WEAK completion evidence (a false
-// idle): insufficient evidence level, review-recommended, or a missing-final-assistant
-// completion diagnostic. Mirrors isWeakTerminalLedgerPayload in mesh-events-coordinator —
-// a weak terminal is non-authoritative and may be superseded by a genuine completion.
-function isWeakCompletionLedgerPayload(payload: Record<string, unknown> | undefined): boolean {
-    if (!payload) return false;
-    if (payload.evidenceLevel === 'insufficient' || payload.reviewRecommended === true) return true;
-    const diag = readRecord(payload.completionDiagnostic);
-    return diag?.finalAssistantPresent === false || diag?.blockReason === 'missing_final_assistant';
-}
-
 export function findTerminalLedgerEvidenceForTask(args: {
     meshId: string;
     taskId?: string;
@@ -100,7 +89,7 @@ export function findTerminalLedgerEvidenceForTask(args: {
         if (entry.kind !== 'task_completed' && entry.kind !== 'task_failed' && entry.kind !== 'task_stalled') continue;
         const terminalTaskId = readNonEmptyString(entry.payload?.taskId);
         if (terminalTaskId !== taskId) continue;
-        if (entry.kind === 'task_completed' && isWeakCompletionLedgerPayload(entry.payload)) continue;
+        if (entry.kind === 'task_completed' && isWeakCompletionEvidence(entry.payload)) continue;
         if (args.sessionId && entry.sessionId && entry.sessionId !== args.sessionId) continue;
         if (!args.sessionId && args.nodeId && entry.nodeId && !meshNodeIdMatches(entry as unknown as MeshNodeIdentified, args.nodeId)) continue;
         return { id: entry.id, kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
@@ -160,7 +149,7 @@ function hasTerminalLedgerAfterDispatch(args: {
         // evidence. Skip it so the transcript reconcile can still synthesize the GENUINE
         // completion for a re-dispatched / prematurely-terminated direct task instead of
         // bailing with alreadyTerminal.
-        if (entry.kind === 'task_completed' && isWeakCompletionLedgerPayload(entry.payload)) continue;
+        if (entry.kind === 'task_completed' && isWeakCompletionEvidence(entry.payload)) continue;
         const terminalTaskId = readNonEmptyString(entry.payload?.taskId);
         if (terminalTaskId && terminalTaskId === args.taskId) return true;
         if (terminalTaskId && terminalTaskId !== args.taskId) continue;

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

@@ -195,23 +195,61 @@ function readEventTimestampValue(value: unknown): number {
     return 0;
 }
 
-// A completion whose evidence is WEAK: the worker FSM reached idle but the turn's
-// final assistant message was never confirmed (missing_final_assistant / a
-// finalAssistantPresent=false diagnostic), or the event self-declares insufficient/weak
-// evidence. cli-provider-instance emits this on the CANON-C decoupled-immediate path and
-// on a forced finalization timeout, and the new structural approval-resolution gate
-// (FALSEIDLE-a) can also let an unconfirmed approval→idle through. Such a completion is NOT
-// trustworthy terminal evidence — surface a verify hint so the coordinator confirms via
-// mesh_read_chat / git status before declaring the task done. Mirrors
-// isWeakCompletionMetadata in mesh-events-pending.ts.
-export function isWeakCompletionMetadata(metadataEvent: Record<string, unknown>): boolean {
-    const evidenceLevel = readNonEmptyString(metadataEvent.evidenceLevel);
-    if (evidenceLevel === 'insufficient' || evidenceLevel === 'weak') return true;
-    if (metadataEvent.reviewRecommended === true) return true;
-    const diag = readRecord(metadataEvent.completionDiagnostic);
+// The completionDiagnostic "false idle" clause, extracted from the five inline copies
+// it used to be duplicated into (the ledger / metadata weak checks and isFalseIdleCompletion).
+// True when the worker FSM dropped to idle WITHOUT a confirmed final assistant message for
+// the turn — a finalization timeout or a "scheduled fallback" idle. cli-provider-instance
+// emits this as completionDiagnostic.blockReason='missing_final_assistant' /
+// finalAssistantPresent=false. The diagnostic lives at the same `completionDiagnostic` field
+// on both a ledger terminal payload and a live metadata event, so one helper serves both.
+export function isMissingFinalAssistantDiagnostic(record: Record<string, unknown> | undefined): boolean {
+    const diag = readRecord(record?.completionDiagnostic);
     return diag?.finalAssistantPresent === false || diag?.blockReason === 'missing_final_assistant';
 }
 
+// A false-idle completion: the provider dropped to idle WITHOUT a confirmed final assistant
+// message (the completionDiagnostic missing-final-assistant signal). This is a strict SUBSET
+// of weak-completion evidence — it DELIBERATELY ignores evidenceLevel/reviewRecommended,
+// because isGenuineCompletionEvidence (coordinator) gates the truncated-terminal supersession
+// on the false-idle distinction alone. Folding evidenceLevel/reviewRecommended in here would
+// change that genuine-completion judgement, so keep this narrow.
+export function isFalseIdleCompletion(record: Record<string, unknown>): boolean {
+    return isMissingFinalAssistantDiagnostic(record);
+}
+
+// A completion whose evidence is WEAK: the worker FSM reached idle but the turn's final
+// assistant message was never confirmed (missing_final_assistant / finalAssistantPresent=false),
+// or the event self-declares insufficient/weak evidence, or a review is recommended. The single
+// source of truth that the live metadata path (mesh-events-pending fingerprint, this module's
+// system-message builder) AND the ledger-terminal paths (mesh-events-coordinator supersession,
+// mesh-events-stale reconcile) all share — the same evidenceLevel / reviewRecommended /
+// completionDiagnostic fields appear on a terminal ledger payload and on a live metadata event.
+//
+// cli-provider-instance emits this on the CANON-C decoupled-immediate path and on a forced
+// finalization timeout, and the structural approval-resolution gate (FALSEIDLE-a) can also let
+// an unconfirmed approval→idle through. Such a completion is NOT trustworthy terminal evidence:
+// a later genuine completion (live path) or a transcript reconcile (fallback path) may supersede
+// it, and the coordinator surfaces a verify hint before declaring the task done.
+//
+// NOTE: this intentionally treats evidenceLevel 'weak' as weak — the ledger variants used to
+// omit it, so a producer emitting 'weak' would have had its weak terminal misjudged as
+// authoritative (genuine completion could no longer supersede it). Applying it uniformly here
+// seals that latent divergence.
+export function isWeakCompletionEvidence(record: Record<string, unknown> | undefined): boolean {
+    if (!record) return false;
+    const evidenceLevel = readNonEmptyString(record.evidenceLevel);
+    if (evidenceLevel === 'insufficient' || evidenceLevel === 'weak') return true;
+    if (record.reviewRecommended === true) return true;
+    return isMissingFinalAssistantDiagnostic(record);
+}
+
+// Back-compat alias for the live metadata-event call sites (system-message builder below,
+// pending-event fingerprint). Identical to isWeakCompletionEvidence; kept as a named export so
+// the metadata-flavoured call sites read naturally.
+export function isWeakCompletionMetadata(metadataEvent: Record<string, unknown>): boolean {
+    return isWeakCompletionEvidence(metadataEvent);
+}
+
 function formatCompletionMetadata(event: Record<string, unknown>): string {
     const completionDiagnostic = event.completionDiagnostic && typeof event.completionDiagnostic === 'object'
         ? event.completionDiagnostic as Record<string, unknown>

package/src/mesh/mesh-ledger-reconciliation.ts

@@ -34,7 +34,6 @@ export interface MeshLedgerReconciliationEvidence {
     sourceOfTruth: {
         kind: 'coordinator_local_sqlite';
         p2pOnly: true;
-        cloudD1LedgerSync: false;
         notes: string;
     };
     replicas: MeshLedgerReplicaEvidence[];
@@ -100,7 +99,6 @@ export function buildMeshLedgerReconciliationEvidence(meshId: string, replicas:
         sourceOfTruth: {
             kind: 'coordinator_local_sqlite',
             p2pOnly: true,
-            cloudD1LedgerSync: false,
             notes: 'Coordinator reconciles bounded slices from daemon-local SQLite event ledgers (mesh_event_ledger table) over P2P DataChannel; Cloud/D1 is not a ledger source of truth.',
         },
         replicas,