@adhdev/daemon-core 0.9.82-rc.423 → 0.9.82-rc.425

package/dist/mesh/mesh-ledger.d.ts

@@ -58,7 +58,7 @@ export interface MeshWorkerResultArtifact {
     errors: string[];
     nextAction?: string;
     requiresUserAction: boolean;
-    source: 'explicit_metadata' | 'final_summary_json' | 'default';
+    source: 'explicit_metadata' | 'final_summary_json' | 'parseable_answer' | 'default';
 }
 export interface MeshTaskCompletionEvidence {
     source: 'agent_status_event';

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

@@ -16,6 +16,19 @@ type PersistableCliHistoryMessage = {
     senderName?: string;
     receivedAt?: number;
 };
+/**
+ * NOTIF Defect-2a: the REPORTED short-generating duration, anchored on the IMMUTABLE turn
+ * start. generatingStartedAt is reset to 0 on every mid-turn waiting_approval/idle blip and
+ * re-armed on the next →generating, so a long turn that blips would otherwise measure only the
+ * final 1.5-2.5s sliver. engine.currentTurnStartedAt (set once at onTurnStarted, surviving
+ * mid-turn blips until the next turn starts) is preferred; generatingStartedAt is the fallback
+ * for turns that never recorded an engine turn start. Returns 0 when neither anchor is set.
+ * Pure / unit-testable.
+ */
+export declare function computeTurnAnchoredDurationMs(engineTurnStartedAt: number | undefined, generatingStartedAt: number, now: number): {
+    durationMs: number;
+    anchor: 'turn-start' | 'generatingStartedAt' | 'none';
+};
 export declare function buildCliStructuredInputPrompt(input: InputEnvelope, options?: {
     materializeDir?: string;
 }): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.423",
+  "version": "0.9.82-rc.425",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.423",
+    "@adhdev/mesh-shared": "0.9.82-rc.425",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/mesh/mesh-event-forwarding.ts

@@ -1174,6 +1174,11 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                         : undefined,
                     evidence: completionEvidence,
                     // B2: evidenceLevel lets coordinator know when completion evidence is insufficient.
+                    // NOTIF Defect-2b: ONLY source==='default' (no parseable answer at all) is
+                    // 'insufficient'. 'parseable_answer' (a real JSON answer that just isn't
+                    // worker-result-shaped, e.g. a MAGI envelope) is concrete evidence and must
+                    // resolve to 'sufficient' — resolveWorkerResult now upgrades that case so a
+                    // complete, valid answer is no longer mislabelled insufficient/reviewRecommended.
                     ...(completionEvidence
                         ? completionEvidence.workerResult.source === 'default'
                             ? { evidenceLevel: 'insufficient', reviewRecommended: true }

package/src/mesh/mesh-ledger.ts

@@ -126,7 +126,14 @@ export interface MeshWorkerResultArtifact {
     errors: string[];
     nextAction?: string;
     requiresUserAction: boolean;
-    source: 'explicit_metadata' | 'final_summary_json' | 'default';
+    // NOTIF Defect-2b: `parseable_answer` = the final summary held a parseable JSON
+    // ANSWER (e.g. a MAGI claim_audit / rca envelope) that is NOT worker-result-shaped
+    // (no status + changedFiles/errors/…). It is still concrete evidence that the worker
+    // produced a real, parseable answer — so it must NOT be labelled evidenceLevel
+    // 'insufficient' — but it is NOT a self-attributing worker result, so it is deliberately
+    // distinct from 'final_summary_json' and stays subject to the direct-dispatch grace gate
+    // in mesh-events-stale.ts (which keys on `!== 'final_summary_json'`).
+    source: 'explicit_metadata' | 'final_summary_json' | 'parseable_answer' | 'default';
 }
 
 export interface MeshTaskCompletionEvidence {
@@ -508,6 +515,35 @@ export function normalizeMeshWorkerResult(input?: Record<string, unknown>, sourc
     };
 }
 
+/**
+ * NOTIF Defect-2b: does the summary contain ANY parseable JSON object answer (not just a
+ * worker-result-shaped one)? Some providers (and every MAGI replica) emit a complete, valid
+ * answer as a JSON envelope that has no `status`/`changedFiles` worker-result fields, so
+ * extractJsonObjectFromSummary returns undefined and the completion is mislabelled
+ * source='default' → evidenceLevel='insufficient' even though a real answer was produced.
+ * This is a conservative existence check: it only returns true when a JSON object actually
+ * parses out of the summary (raw or fenced), so an empty / prose-only / unparseable summary
+ * still resolves to 'default'.
+ */
+function summaryHasParseableJsonAnswer(summary?: string): boolean {
+    const text = readNonEmptyString(summary);
+    if (!text) return false;
+    const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+    const candidates = [fenced?.[1], text].filter(Boolean) as string[];
+    for (const candidate of candidates) {
+        const trimmed = candidate.trim();
+        if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+                && Object.keys(parsed).length > 0) {
+                return true;
+            }
+        } catch { /* try next candidate */ }
+    }
+    return false;
+}
+
 function resolveWorkerResult(opts: BuildTaskCompletionEvidenceOptions): MeshWorkerResultArtifact {
     if (opts.workerResult && typeof opts.workerResult === 'object') {
         return normalizeMeshWorkerResult(opts.workerResult, 'explicit_metadata');
@@ -516,6 +552,13 @@ function resolveWorkerResult(opts: BuildTaskCompletionEvidenceOptions): MeshWork
     if (parsed) {
         return normalizeMeshWorkerResult(parsed, 'final_summary_json');
     }
+    // NOTIF Defect-2b: no worker-result-shaped JSON, but a parseable JSON answer IS present
+    // (the common MAGI / answer-only case). Treat it as concrete evidence so the completion is
+    // not labelled 'insufficient', while keeping the worker-result fields empty (status stays
+    // 'unknown') — we only know an answer parsed, not its task outcome.
+    if (summaryHasParseableJsonAnswer(opts.finalSummary)) {
+        return normalizeMeshWorkerResult(undefined, 'parseable_answer');
+    }
     return normalizeMeshWorkerResult(undefined, 'default');
 }
 

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

@@ -44,7 +44,7 @@ import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
 import type { LocalMeshEntry } from '../repo-mesh-types.js';
 import { loadConfig } from '../config/config.js';
 import { listMeshes } from '../config/mesh-config.js';
-import { LOG } from '../logging/logger.js';
+import { LOG, getLogLevel } from '../logging/logger.js';
 import { drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, buildPendingEventFingerprint, queuePendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import type { PendingMeshCoordinatorEvent } from './mesh-events-pending.js';
 import { appendLedgerEntry } from './mesh-ledger.js';
@@ -319,6 +319,38 @@ function findLiveCoordinators(components: DaemonComponents): LiveCoordinator[] {
             ? (inst as any).isModalParked() === true
             : (status === 'waiting_choice' || status === 'waiting_approval');
         const sessionId = readNonEmptyString(state.instanceId);
+        // ── NOTIF (B) desync diagnostic (read-only, no behavior change) ───────────
+        // The confirmed (B) defect: a coordinator whose FSM is idle (status above ===
+        // 'idle' for minutes) is nonetheless classified busy here, so the generating/
+        // modal-park hold never drains and a worker completion is stranded until the
+        // user's next turn edge. Static analysis found no code path where getState()
+        // returns generating while lastStatus and the adapter raw are both idle — so the
+        // divergence is a runtime desync between the three status sources. Capture all
+        // three (plus the auto-approve mask state that getState() overlays at :803) for
+        // EVERY mesh-coordinator candidate on this tick, so the source that diverges from
+        // the others can be read directly against the same-tick "skip → generating"/
+        // "skip → modal-parked" hold logs below (pair by sessionId + timestamp).
+        //
+        // CRITICAL: reuse the `state` already fetched above (line ~301) — do NOT call
+        // getState() again. getState() runs maybeAutoApproveStatus() as a side effect,
+        // which would mutate the very auto-approve mask we are trying to observe. The
+        // adapter raw read uses allowParse:false, which only reads engine.activeModal and
+        // is side-effect-free.
+        if (getLogLevel() === 'debug') {
+            let adapterRaw = '?';
+            try {
+                const a = (inst as any).adapter;
+                if (a && typeof a.getStatus === 'function') {
+                    adapterRaw = readNonEmptyString(a.getStatus({ allowParse: false })?.status) || '?';
+                }
+            } catch (e: any) {
+                adapterRaw = `err:${e?.message || e}`;
+            }
+            const lastStatus = readNonEmptyString((inst as any).lastStatus) || '?';
+            const autoApproveBusy = (inst as any).autoApproveBusy;
+            const maskSince = (inst as any).autoApproveMaskSince;
+            LOG.debug('MeshReconcile', `coordDiag sess=${sessionId || '?'} mesh=${meshId} getState=${status || '?'} lastStatus=${lastStatus} adapterRaw=${adapterRaw} autoApproveBusy=${autoApproveBusy === true} maskSince=${maskSince || 0}`);
+        }
         // 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
@@ -902,6 +934,12 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
                     }
                 }
                 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` : ''})`);
+                // NOTIF (B) diagnostic: name the session(s) classified modal-parked so the
+                // same-tick coordDiag line (paired by sessionId) shows whether the modal-park
+                // overlay is a real human-await or an unreleased mask (the getState_overlay origin).
+                if (getLogLevel() === 'debug') {
+                    LOG.debug('MeshReconcile', `coordHoldModalParked mesh=${meshId} heldFor=[${modalParkedCoordinators.map(c => c.sessionId || '?').join(',')}] (these were classified modal-parked; cross-ref same-tick coordDiag by sessionId)`);
+                }
                 // 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.
@@ -937,6 +975,14 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
                 }
                 if (hasPending) {
                     LOG.info('MeshReconcile', `Reconcile skip → generating: holding pending event(s) for mesh ${meshId} (${generatingCoordinators.length} coordinator(s) busy; events left queued for the next idle tick)`);
+                    // NOTIF (B) diagnostic: this is the hold that strands the completion. Name
+                    // the sessionId(s) the loop just classified non-idle/non-modal so the
+                    // same-tick coordDiag line above (paired by sessionId) reveals which status
+                    // source diverged. If a coordDiag for one of these sessions shows getState
+                    // (or lastStatus/adapterRaw) === idle, that is the runtime desync origin.
+                    if (getLogLevel() === 'debug') {
+                        LOG.debug('MeshReconcile', `coordHoldGenerating mesh=${meshId} heldFor=[${generatingCoordinators.map(c => c.sessionId || '?').join(',')}] (these were classified busy; cross-ref same-tick coordDiag by sessionId)`);
+                    }
                     recordHeldTerminalEventsToLedger(
                         meshId,
                         drainDaemonIds.length > 0 ? drainDaemonIds : (localDaemonId ? [localDaemonId] : []),

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

@@ -249,6 +249,28 @@ function isCliGeneratingLikeStatus(status: unknown): boolean {
     return status === 'generating' || status === 'streaming' || status === 'no_progress' || status === 'long_generating' || status === 'starting';
 }
 
+/**
+ * NOTIF Defect-2a: the REPORTED short-generating duration, anchored on the IMMUTABLE turn
+ * start. generatingStartedAt is reset to 0 on every mid-turn waiting_approval/idle blip and
+ * re-armed on the next →generating, so a long turn that blips would otherwise measure only the
+ * final 1.5-2.5s sliver. engine.currentTurnStartedAt (set once at onTurnStarted, surviving
+ * mid-turn blips until the next turn starts) is preferred; generatingStartedAt is the fallback
+ * for turns that never recorded an engine turn start. Returns 0 when neither anchor is set.
+ * Pure / unit-testable.
+ */
+export function computeTurnAnchoredDurationMs(
+    engineTurnStartedAt: number | undefined,
+    generatingStartedAt: number,
+    now: number,
+): { durationMs: number; anchor: 'turn-start' | 'generatingStartedAt' | 'none' } {
+    const engineStart = typeof engineTurnStartedAt === 'number' && Number.isFinite(engineTurnStartedAt)
+        ? engineTurnStartedAt
+        : 0;
+    if (engineStart > 0) return { durationMs: now - engineStart, anchor: 'turn-start' };
+    if (generatingStartedAt > 0) return { durationMs: now - generatingStartedAt, anchor: 'generatingStartedAt' };
+    return { durationMs: 0, anchor: 'none' };
+}
+
 export function buildCliStructuredInputPrompt(
     input: InputEnvelope,
     options: { materializeDir?: string } = {},
@@ -2375,8 +2397,21 @@ export class CliProviderInstance implements ProviderInstance {
                 // Still emit agent:generating_completed so mesh orchestration can record
                 // task_completed for direct dispatches that complete faster than the debounce.
                 if (this.generatingDebouncePending) {
-                    const shortDurationMs = this.generatingStartedAt ? now - this.generatingStartedAt : 0;
-                    LOG.info('CLI', `[${this.type}] suppressed short generating (${shortDurationMs}ms)`);
+                    // NOTIF Defect-2a: shortDurationMs is the REPORTED turn duration, so it must be
+                    // measured from the IMMUTABLE turn start — not generatingStartedAt, which is
+                    // reset to 0 on every mid-turn waiting_approval/idle blip (see :1864/1885/2397/
+                    // 2503/2521) and re-armed on the next →generating, so a long turn that blipped
+                    // would measure only the final 1.5-2.5s sliver. engine.currentTurnStartedAt is
+                    // stamped once at onTurnStarted and persists past mid-turn blips until the next
+                    // turn starts, so it captures the true turn length. generatingStartedAt remains
+                    // the fallback (and the debounce itself stays a pure UI-suppression signal,
+                    // decoupled from the reported duration).
+                    const { durationMs: shortDurationMs, anchor: durationAnchor } = computeTurnAnchoredDurationMs(
+                        (this.adapter as any)?.currentTurnStartedAt,
+                        this.generatingStartedAt,
+                        now,
+                    );
+                    LOG.info('CLI', `[${this.type}] suppressed short generating (${shortDurationMs}ms, anchor=${durationAnchor})`);
                     if (this.generatingDebounceTimer) { clearTimeout(this.generatingDebounceTimer); this.generatingDebounceTimer = null; }
                     // Emit completion for mesh task association even though the UI generating
                     // started/completed pair is suppressed (too short for visible UI update).