@adhdev/daemon-core 0.9.82-rc.361 → 0.9.82-rc.363

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

@@ -195,6 +195,23 @@ 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);
+    return diag?.finalAssistantPresent === false || diag?.blockReason === 'missing_final_assistant';
+}
+
 function formatCompletionMetadata(event: Record<string, unknown>): string {
     const completionDiagnostic = event.completionDiagnostic && typeof event.completionDiagnostic === 'object'
         ? event.completionDiagnostic as Record<string, unknown>
@@ -229,6 +246,13 @@ export function buildMeshSystemMessage(args: {
             return `[System] ${args.nodeLabel} already has completion evidence${metadata}. The no-progress monitor reconciled the terminal handoff and marked the session complete; wait for the queued completion event/status refresh before doing any manual transcript check.`;
         }
         const reviewRecommended = args.metadataEvent.reviewRecommended === true;
+        // FALSEIDLE-b: a weak completion (missing final assistant / finalAssistantPresent=false /
+        // insufficient evidence) is not trustworthy terminal evidence even when reviewRecommended
+        // is not set. Append an explicit verify hint so the coordinator does not declare the task
+        // done off a false idle. Only the weak case is affected — a genuine completion (final
+        // assistant confirmed, no weak diagnostic) carries no extra note and is unchanged.
+        const weakCompletion = isWeakCompletionMetadata(args.metadataEvent);
+        const verifyTextNote = ' Completion evidence is weak — verify via mesh_read_chat or git status before declaring the task done; the worker may still be parked on an approval/modal.';
         // Auto-surface the worker's final summary directly into the coordinator chat so it
         // does not have to call mesh_read_chat just to see the result. The summary IS the
         // worker's final assistant message; embedding it here replaces the previous
@@ -244,12 +268,14 @@ export function buildMeshSystemMessage(args: {
                 : completionSummary;
             const verifyNote = reviewRecommended
                 ? ' Completion evidence is insufficient — verify via git status or provider_session_id before assuming the task is done.'
-                : '';
+                : (weakCompletion ? verifyTextNote : '');
             return `[System] ${args.nodeLabel} has completed its task and is now idle${metadata}. Its final summary is included below — read it directly and only call mesh_read_chat if you need the full transcript.${verifyNote}\n\n--- ${args.nodeLabel} final summary ---\n${surfaced}`;
         }
         const reviewNote = reviewRecommended
             ? ' Completion evidence is insufficient — verify via git status or provider_session_id before assuming the task is done. Use mesh_read_chat once if needed, but do not poll repeatedly.'
-            : ' Use mesh_read_chat once to review its final progress, but do not poll repeatedly.';
+            : (weakCompletion
+                ? `${verifyTextNote} Use mesh_read_chat once if needed, but do not poll repeatedly.`
+                : ' Use mesh_read_chat once to review its final progress, but do not poll repeatedly.');
         return `[System] ${args.nodeLabel} has completed its task and is now idle${metadata}. This completion came from the agent status event path;${reviewNote}`;
     }
     if (args.event === 'agent:waiting_approval') {

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

@@ -1401,6 +1401,12 @@ export class CliProviderInstance implements ProviderInstance {
             }
         }
 
+        // (FALSEIDLE-a) Structural approval-resolution gate. Runs BEFORE the brittle
+        // screen-text heuristic below so it also catches modals whose text does not match
+        // looksLikeActiveApprovalPromptText (e.g. claude-cli's cd / "untrusted hooks" prompt).
+        const approvalResolutionBlock = this.approvalResolutionFinalizationBlock(pending);
+        if (approvalResolutionBlock) return approvalResolutionBlock;
+
         // Guard: if the screen still shows an approval/choice prompt as the last visible text,
         // the turn is not complete even if the parsed status says idle and there is an assistant
         // message. This catches the case where waiting_approval→idle transitions occur before
@@ -1420,6 +1426,46 @@ export class CliProviderInstance implements ProviderInstance {
         return null;
     }
 
+    // (FALSEIDLE-a) Positive, structural proof that the latest approval entry was resolved
+    // through ADHDev. resolveModal() — driven by auto-approve, dashboard/mesh_approve, and
+    // dev-cli-debug alike — advances the engine's lastResolvedEntrySeq to the current
+    // approvalEntrySeq. So `lastResolvedEntrySeq >= approvalEntrySeq` (with a real entry,
+    // approvalEntrySeq > 0) means the modal we last saw was actually answered. Absence of this
+    // evidence after a waiting_approval→idle transition means the idle is suspect: the spec's
+    // text-based approval→idle rule false-tripped while the modal is still unresolved.
+    // Fails OPEN (returns true) when the seq fields are unavailable, so the gate can never wedge
+    // a session on a provider/adapter that does not surface the counters.
+    private hasApprovalResolutionEvidence(): boolean {
+        try {
+            const status = this.adapter.getStatus({ allowParse: false }) as any;
+            const entrySeq = typeof status?.approvalEntrySeq === 'number' ? status.approvalEntrySeq : 0;
+            if (entrySeq <= 0) return true;
+            const resolvedSeq = typeof status?.lastResolvedEntrySeq === 'number' ? status.lastResolvedEntrySeq : undefined;
+            if (resolvedSeq === undefined) return true;
+            return resolvedSeq >= entrySeq;
+        } catch {
+            return true;
+        }
+    }
+
+    // (FALSEIDLE-a) Hold a completion that is the anomalous DIRECT waiting_approval→idle
+    // transition with no positive resolution evidence. A genuinely resolved approval routes
+    // through resolveModal → setStatus('generating'), so its completion's previousStatus is
+    // 'generating' (not 'waiting_approval') and this gate never fires for it. Scoped to
+    // delegated mesh/coordinator sessions — whose only modal-resolution path is auto-approve /
+    // mesh_approve (both advance lastResolvedEntrySeq) — so an interactive local session, where
+    // a human may answer the PTY prompt directly and leave no resolveModal record, is untouched.
+    // Non-terminal: the hold is bounded by COMPLETED_FINALIZATION_MAX_WAIT_MS (30s), giving a
+    // settling auto-approve time to fire and advance the seq, and guaranteeing no permanent wedge
+    // if resolution ever happens via a path that does not record evidence.
+    private approvalResolutionFinalizationBlock(pending: CompletedDebouncePending): CompletedFinalizationBlock | null {
+        if (pending.previousStatus !== 'waiting_approval') return null;
+        const meshContext = !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.launchedByCoordinator);
+        if (!meshContext) return null;
+        if (this.hasApprovalResolutionEvidence()) return null;
+        return { reason: 'approval_resolution_unconfirmed', terminal: false };
+    }
+
     private scheduleCompletedDebounceFlush(delayMs: number): void {
         if (this.completedDebounceTimer) clearTimeout(this.completedDebounceTimer);
         this.completedDebounceTimer = setTimeout(() => this.flushCompletedDebounceIfFinalized(), delayMs);