@adhdev/daemon-core 0.9.82-rc.422 → 0.9.82-rc.424

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.422",
+  "version": "0.9.82-rc.424",
   "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.422",
+    "@adhdev/mesh-shared": "0.9.82-rc.424",
     "@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/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).