@adhdev/daemon-core 0.9.82-rc.350 → 0.9.82-rc.351

package/dist/mesh/mesh-runtime-store.d.ts

@@ -6,6 +6,7 @@ export declare class MeshRuntimeStore {
     private readonly migratedMeshIds;
     private fingerprintSweepCounter;
     private walWriteCounter;
+    private toolCallLogCounter;
     private static readonly WAL_CHECK_INTERVAL;
     private static readonly WAL_MAX_BYTES;
     private constructor();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.350",
+  "version": "0.9.82-rc.351",
   "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.350",
+    "@adhdev/mesh-shared": "0.9.82-rc.351",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/index.ts

@@ -252,6 +252,11 @@ export { buildMeshHostRequiredFailure, createDefaultMeshHostMetadata, isMeshHost
 // ── Mesh Events ──
 export { triggerMeshQueue, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, queuePendingMeshCoordinatorEvent, reconcileDirectDispatchCompletionFromTranscript } from './mesh/mesh-events.js';
 export type { PendingMeshCoordinatorEvent } from './mesh/mesh-events.js';
+// The coordinator-side preview surfaced from a worker's completion/status event
+// (finalSummary / workerResult.summary / lastMessagePreview). Same data the mobile
+// inbox is fed; reused by mesh_read_chat's cache fallback when the live P2P read path
+// is unavailable (saturated/unreachable peer).
+export { resolveMeshSurfacedSessionPreview, readMeshCompletionSummary } from './mesh/mesh-events-utils.js';
 
 // ── Mesh Delivery Policy ──
 export { resolveDeliveryDecision, createSessionDelivery, updateSessionDeliveryStatus, getActiveSessionDeliveries, markSessionDeliveriesTerminal, recordCompletionConflict, getRecentCompletionConflicts } from './mesh/mesh-delivery-policy.js';

package/src/mesh/mesh-active-work.ts

@@ -168,6 +168,46 @@ function statusFromTerminal(entry: MeshLedgerEntry): MeshActiveWorkStatus {
     return 'failed';
 }
 
+const LEDGER_ONLY_STALE_REASON =
+    'direct task dispatch has no provider acknowledgement, transcript append, or active runtime transition';
+
+/**
+ * Single source of truth for classifying whether a direct dispatch is ledger-only
+ * stale (dispatched but never acknowledged: no provider ack, no transcript append,
+ * no runtime transition) and whether that staleness is "fresh unacknowledged"
+ * (target session still live) vs. an orphaned historical record.
+ *
+ * Previously this predicate was inlined in all three dispatch-classification blocks
+ * (MeshRuntimeStore path, remote-ledger path, full-ledger path) and had drifted —
+ * e.g. one block gated `isIdleUnacknowledged` on `!isTerminal` and another did not.
+ * Extracting it keeps the three callers byte-for-byte consistent. Status derivation
+ * stays per-block: it genuinely differs by data source and is passed in via `status`.
+ */
+function classifyDirectDispatch(params: {
+    /** Final classified status of the dispatch. */
+    status: MeshActiveWorkStatus;
+    /** True when a real terminal row applies (completed/failed/stale); excludes approval_needed. Gates the stale verdict. */
+    isTerminalRow: boolean;
+    /** True when any terminal-derived status exists (incl. approval_needed). Used to detect "no transition". */
+    hasTerminalStatus: boolean;
+    /** Live session status from the mesh nodes, if any. */
+    liveStatus?: string;
+    /** Live stale reason from the mesh nodes, if any. */
+    liveStaleReason?: string;
+    /** Whether the dispatch targeted an already-idle session. */
+    dispatchedToIdleSession: boolean;
+}): { ledgerOnlyStaleReason: string | undefined; isFreshUnacknowledged: boolean } {
+    const { status, isTerminalRow, hasTerminalStatus, liveStatus, liveStaleReason, dispatchedToIdleSession } = params;
+    const isNoTransition = !hasTerminalStatus && !liveStatus;
+    const isIdleUnacknowledged = status === 'idle';
+    const ledgerOnlyStaleReason =
+        !isTerminalRow && (isIdleUnacknowledged || isNoTransition || (dispatchedToIdleSession && isIdleUnacknowledged))
+            ? LEDGER_ONLY_STALE_REASON
+            : undefined;
+    const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !liveStaleReason);
+    return { ledgerOnlyStaleReason, isFreshUnacknowledged };
+}
+
 export function buildMeshActiveWorkSummary(activeWork: MeshActiveWorkRecord[]): MeshActiveWorkSummary {
     const statusCounts: Record<MeshActiveWorkStatus, number> = {
         pending: 0,
@@ -239,12 +279,14 @@ export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeW
             const status: MeshActiveWorkStatus = isTerminal
                 ? (dbStatus === 'completed' ? 'idle' : 'failed')
                 : live.status || (dbStatus === 'acked' ? 'generating' : 'assigned');
-            const isNoTransition = !isTerminal && !live.status;
-            const isIdleUnacknowledged = status === 'idle' && !isTerminal;
-            const ledgerOnlyStaleReason = !isTerminal && (isIdleUnacknowledged || isNoTransition || (dispatch.dispatchedToIdleSession && isIdleUnacknowledged))
-                ? 'direct task dispatch has no provider acknowledgement, transcript append, or active runtime transition'
-                : undefined;
-            const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !live.staleReason);
+            const { ledgerOnlyStaleReason, isFreshUnacknowledged } = classifyDirectDispatch({
+                status,
+                isTerminalRow: isTerminal,
+                hasTerminalStatus: isTerminal,
+                liveStatus: live.status,
+                liveStaleReason: live.staleReason,
+                dispatchedToIdleSession: dispatch.dispatchedToIdleSession === true,
+            });
             const { title, summary } = summarizeMessage(dispatch.message || '');
             const record: MeshActiveWorkRecord = {
                 taskId: dispatch.taskId,
@@ -291,15 +333,16 @@ export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeW
             const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
             const status = terminalStatus || live.status || 'assigned';
             const terminalRow = Boolean(terminal && terminal.kind !== 'task_approval_needed');
-            const dispatchedToIdleSession = dispatch.payload?.dispatchedToIdleSession === true;
-            const isNoTransition = !terminalStatus && !live.status;
-            const isIdleUnacknowledged = status === 'idle';
-            const ledgerOnlyStaleReason = !terminalRow && (isIdleUnacknowledged || isNoTransition || (dispatchedToIdleSession && isIdleUnacknowledged))
-                ? 'direct task dispatch has no provider acknowledgement, transcript append, or active runtime transition'
-                : undefined;
+            const { ledgerOnlyStaleReason, isFreshUnacknowledged } = classifyDirectDispatch({
+                status,
+                isTerminalRow: terminalRow,
+                hasTerminalStatus: Boolean(terminalStatus),
+                liveStatus: live.status,
+                liveStaleReason: live.staleReason,
+                dispatchedToIdleSession: dispatch.payload?.dispatchedToIdleSession === true,
+            });
             const message = readString(dispatch.payload?.message) || readString(dispatch.payload?.summary) || '';
             const { title, summary } = summarizeMessage(message);
-            const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !live.staleReason);
             const record: MeshActiveWorkRecord = {
                 taskId,
                 source: 'direct',
@@ -344,15 +387,16 @@ export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeW
             const live = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
             const status = terminalStatus || live.status || 'assigned';
             const terminalRow = Boolean(terminal && terminal.kind !== 'task_approval_needed');
-            const dispatchedToIdleSession = dispatch.payload?.dispatchedToIdleSession === true;
-            const isNoTransition = !terminalStatus && !live.status;
-            const isIdleUnacknowledged = status === 'idle';
-            const ledgerOnlyStaleReason = !terminalRow && (isIdleUnacknowledged || isNoTransition || (dispatchedToIdleSession && isIdleUnacknowledged))
-                ? 'direct task dispatch has no provider acknowledgement, transcript append, or active runtime transition'
-                : undefined;
+            const { ledgerOnlyStaleReason, isFreshUnacknowledged } = classifyDirectDispatch({
+                status,
+                isTerminalRow: terminalRow,
+                hasTerminalStatus: Boolean(terminalStatus),
+                liveStatus: live.status,
+                liveStaleReason: live.staleReason,
+                dispatchedToIdleSession: dispatch.payload?.dispatchedToIdleSession === true,
+            });
             const message = readString(dispatch.payload?.message) || readString(dispatch.payload?.summary) || '';
             const { title, summary } = summarizeMessage(message);
-            const isFreshUnacknowledged = Boolean(ledgerOnlyStaleReason && !live.staleReason);
             const record: MeshActiveWorkRecord = {
                 taskId,
                 source: 'direct',

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

@@ -251,6 +251,55 @@ function isDuplicateRefineTerminalEvent(meshId: string, eventName: string, metad
     return false;
 }
 
+// A worker/coordinator "false idle": the provider dropped to idle WITHOUT a confirmed
+// final assistant message for the turn (a finalization timeout, or a "scheduled fallback"
+// idle). This is the signal cli-provider-instance emits as
+// completionDiagnostic.blockReason='missing_final_assistant' / finalAssistantPresent=false.
+// Such a completion is NOT trustworthy terminal evidence: it must neither permanently
+// terminate a direct-dispatch task nor suppress the genuine completion a later turn
+// (commonly driven by a coordinator nudge / re-dispatch) produces.
+function isFalseIdleCompletion(metadataEvent: Record<string, unknown>): boolean {
+    const diag = readRecord(metadataEvent.completionDiagnostic);
+    if (!diag) return false;
+    return diag.finalAssistantPresent === false || diag.blockReason === 'missing_final_assistant';
+}
+
+// The genuine-completion counterpart: a real final summary / worker result is present and
+// the completion is not flagged as a missing-final-assistant false idle. Used to decide
+// whether a new completion may supersede a prior WEAK (false-idle) terminal.
+function isGenuineCompletionEvidence(metadataEvent: Record<string, unknown>): boolean {
+    if (isFalseIdleCompletion(metadataEvent)) return false;
+    return !!readWorkerResultMetadata(metadataEvent) || !!readNonEmptyString(metadataEvent.finalSummary);
+}
+
+// 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. A weak terminal is non-authoritative — a later genuine completion
+// (live path) or a transcript reconcile (fallback path) may supersede it.
+function isWeakTerminalLedgerPayload(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';
+}
+
+// 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
+// entry (and thus mesh task-stats) to — without it the terminal carries no taskId and the
+// task surfaces as status='unknown' / terminalKind=null in computeMeshTaskStats.
+function resolveActiveDirectDispatchTaskId(meshId: string, sessionId: string): string | undefined {
+    try {
+        const matches = getActiveDirectDispatches(meshId).filter(d => d.sessionId === sessionId);
+        if (!matches.length) return undefined;
+        // getActiveDirectDispatches returns rows ordered by dispatched_at ASC; the last is
+        // the most recent dispatch (the re-dispatch / nudge whose completion this is).
+        return readNonEmptyString(matches[matches.length - 1].taskId) || undefined;
+    } catch {
+        return undefined;
+    }
+}
+
 // ---------------------------------------------------------------------------
 // Queue assignment
 // ---------------------------------------------------------------------------
@@ -1555,7 +1604,17 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         });
         if (terminal?.kind === 'task_completed' && !sessionHasActiveAssignment(args.meshId, eventSessionId)) {
             const newDispatchAfterTerminal = hasDispatchAfterTerminal(args.meshId, eventSessionId, terminal.id);
-            if (!newDispatchAfterTerminal) {
+            // Fix B (re-dispatch 2nd-completion routing): a prior terminal recorded from a FALSE
+            // idle (weak evidence / no confirmed final assistant) must NOT permanently suppress a
+            // later GENUINE completion of the same session. providerSessionId is stable across a
+            // session's turns, so the providerSessionId/finalSummary dedup below would otherwise
+            // swallow the real 2nd-turn completion that a coordinator nudge (direct re-dispatch)
+            // drove — exactly the missed-event bug. When the prior terminal was weak and the new
+            // event carries genuine completion evidence, let it through so it is recorded and
+            // re-attributed to the latest task (the normal task_completed path below).
+            const supersedesWeakTerminal = isWeakTerminalLedgerPayload(terminal.payload)
+                && isGenuineCompletionEvidence(args.metadataEvent);
+            if (!newDispatchAfterTerminal && !supersedesWeakTerminal) {
                 const terminalProviderSessionId = readNonEmptyString(terminal.payload.providerSessionId);
                 const terminalFinalSummary = readNonEmptyString(terminal.payload.finalSummary);
                 const eventProviderSessionId = readNonEmptyString(args.metadataEvent.providerSessionId);
@@ -1606,7 +1665,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         }
     }
 
-    function markSessionTerminal(sessionId: string, outcome: 'completed' | 'failed', occurredAtMs?: number | null): { id?: string } | null {
+    function markSessionTerminal(sessionId: string, outcome: 'completed' | 'failed', occurredAtMs?: number | null, opts?: { tentativeIfDirect?: boolean }): { id?: string } | null {
         // C2: prefer an exact taskId match when the completion event carries one —
         // it's immune to coordinator↔worker clock skew that can hide the assigned row.
         const eventTaskId = readNonEmptyString(args.metadataEvent.taskId) || undefined;
@@ -1614,20 +1673,36 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             occurredAt: occurredAtMs != null ? new Date(occurredAtMs).toISOString() : undefined,
             taskId: eventTaskId,
         });
-        updateDirectDispatchStatus(args.meshId, sessionId, outcome);
+        // Fix A (early-terminal prevention): a false-idle completion (no confirmed final
+        // assistant) for a DIRECT dispatch — i.e. no work-queue row matched — must not flip the
+        // dispatch row terminal. Leaving it active lets the reconcile loop (PHASE 4) re-read the
+        // transcript and record the genuine completion once the worker truly finishes (commonly
+        // after a coordinator nudge / re-dispatch). A matched queue task, or a completion with
+        // genuine evidence, is marked terminal as before.
+        const leaveDirectDispatchActive = !task && opts?.tentativeIfDirect === true;
+        if (!leaveDirectDispatchActive) {
+            updateDirectDispatchStatus(args.meshId, sessionId, outcome);
+        }
         markSessionDeliveriesTerminal(args.meshId, sessionId, outcome);
         setImmediate(() => cleanupTerminalDirectDispatches());
         return task ? { id: task.id } : null;
     }
 
     let completedTaskForLedger: { id?: string } | null = null;
+    // Fix B: direct-dispatch taskId used to attribute the terminal ledger entry when no
+    // work-queue row matches (resolved BEFORE markSessionTerminal flips the dispatch terminal).
+    let directDispatchTaskIdForLedger: string | undefined;
     if (args.event === 'agent:generating_completed') {
         const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
         const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         const providerType = readNonEmptyString(args.metadataEvent.providerType);
 
         if (sessionId) {
-            completedTaskForLedger = markSessionTerminal(sessionId, 'completed', eventTimestamp);
+            directDispatchTaskIdForLedger = resolveActiveDirectDispatchTaskId(args.meshId, sessionId);
+            // A false-idle completion of a direct dispatch is recorded but kept tentative (the
+            // dispatch row stays active for the reconcile fallback); a genuine completion is terminal.
+            const isFalseIdle = isFalseIdleCompletion(args.metadataEvent);
+            completedTaskForLedger = markSessionTerminal(sessionId, 'completed', eventTimestamp, { tentativeIfDirect: isFalseIdle });
             if (nodeId && providerType) {
                 runIdleMaintenanceThenAssignQueue(components, { meshId: args.meshId, nodeId, sessionId, providerType });
             }
@@ -1729,6 +1804,7 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             } catch { /* best-effort */ }
         }
         if (sessionId) {
+            directDispatchTaskIdForLedger = resolveActiveDirectDispatchTaskId(args.meshId, sessionId);
             completedTaskForLedger = markSessionTerminal(sessionId, 'failed');
         }
     }
@@ -1761,7 +1837,10 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                 payload: {
                     event: args.event,
                     nodeLabel: args.nodeLabel,
-                    taskId: completedTaskForLedger?.id || undefined,
+                    // Fix B: fall back to the direct-dispatch taskId when no work-queue row
+                    // matched, so the terminal entry is attributable in mesh task-stats
+                    // (otherwise the direct task shows status='unknown' / terminalKind=null).
+                    taskId: completedTaskForLedger?.id || directDispatchTaskIdForLedger || undefined,
                     providerSessionId,
                     finalSummary,
                     workerResult,

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

@@ -303,6 +303,7 @@ export function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEv
         const fingerprint = buildPendingEventFingerprint(event);
 
         // G3: Write to SQLite inbox (primary path going forward)
+        let sqliteOk = false;
         try {
             MeshRuntimeStore.getInstance().insertPendingEvent({
                 id: randomUUID(),
@@ -313,14 +314,22 @@ export function queuePendingMeshCoordinatorEvent(event: PendingMeshCoordinatorEv
                 fingerprint: fingerprint || null,
                 queuedAt: event.queuedAt,
             });
+            sqliteOk = true;
         } catch {
             // SQLite write failure is non-fatal; JSONL fallback below still works.
         }
 
-        // Also write to JSONL (retained as legacy/export artifact)
-        const path = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
-        trimPendingEventsIfNeeded(path);
-        appendFileSync(path, JSON.stringify(event) + '\n', 'utf-8');
+        // Also write to JSONL (retained as legacy/export artifact). Best-effort once
+        // SQLite (the primary store) has the event: a JSONL append failure (disk full,
+        // permissions) must NOT report the whole persist as failed when SQLite holds it.
+        try {
+            const path = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
+            trimPendingEventsIfNeeded(path);
+            appendFileSync(path, JSON.stringify(event) + '\n', 'utf-8');
+        } catch (e: any) {
+            if (!sqliteOk) throw e; // neither store has it — surface as a real failure
+            LOG.warn('MeshEvents', `JSONL append failed for mesh ${event.meshId}; SQLite holds the event: ${e?.message || e}`);
+        }
         return true;
     } catch (e: any) {
         LOG.warn('MeshEvents', `Failed to persist pending coordinator event: ${e?.message || e}`);

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

@@ -74,6 +74,17 @@ 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';
+}
+
 function findDirectDispatchLedgerEntry(args: {
     meshId: string;
     taskId: string;
@@ -121,6 +132,12 @@ function hasTerminalLedgerAfterDispatch(args: {
             if (!afterDispatch) continue;
         }
         if (entry.kind !== 'task_completed' && entry.kind !== 'task_failed' && entry.kind !== 'task_stalled') continue;
+        // Fix C (reconcile fallback expansion): a task_completed recorded from a FALSE idle
+        // (weak evidence / no confirmed final assistant) is NOT authoritative terminal
+        // 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;
         const terminalTaskId = readNonEmptyString(entry.payload?.taskId);
         if (terminalTaskId && terminalTaskId === args.taskId) return true;
         if (terminalTaskId && terminalTaskId !== args.taskId) continue;

package/src/mesh/mesh-runtime-store.ts

@@ -70,6 +70,10 @@ export class MeshRuntimeStore {
     private readonly migratedMeshIds = new Set<string>();
     private fingerprintSweepCounter = 0;
     private walWriteCounter = 0;
+    // Independent cadence for the tool-call-log sweep. Must NOT share walWriteCounter:
+    // sharing makes each store's threshold drift by the other's write volume (WAL
+    // checkpoint at 500 vs tool-log sweep at 200 would interfere arbitrarily).
+    private toolCallLogCounter = 0;
     private static readonly WAL_CHECK_INTERVAL = 500;
     private static readonly WAL_MAX_BYTES = 50 * 1024 * 1024; // 50 MB
 
@@ -1171,7 +1175,7 @@ export class MeshRuntimeStore {
         const callsInWindow = row?.cnt ?? 0;
 
         // Sweep old entries periodically to keep the table lean (every 200 calls across all tools).
-        if (++this.walWriteCounter % 200 === 0) {
+        if (++this.toolCallLogCounter % 200 === 0) {
             this.db.prepare(
                 'DELETE FROM mesh_tool_call_log WHERE called_at < ?'
             ).run(now - Math.max(windowMs * 10, 60_000));

package/src/mesh/mesh-task-stats.ts

@@ -91,9 +91,16 @@ export function computeMeshTaskStats(meshId: string, opts?: { taskIds?: string[]
 
     return targetIds.map(taskId => {
         const queueEntry = queueById.get(taskId);
-        const status = queueEntry?.status ?? 'unknown';
         const dispatch = dispatches.get(taskId);
         const terminal = terminals.get(taskId);
+        // Direct dispatches (mesh_send_task) have no work-queue row, so queueEntry is undefined.
+        // Derive a terminal status from the attributed terminal ledger entry instead of reporting
+        // status='unknown' — without this a completed direct task showed unknown + terminalKind=null
+        // even though its task_completed event fired (see mesh-events-coordinator Fix B attribution).
+        const status = queueEntry?.status
+            ?? (terminal
+                ? (terminal.kind === 'task_completed' ? 'completed' : 'failed')
+                : 'unknown');
         const isTerminalStatus = status === 'completed' || status === 'failed' || status === 'cancelled';
         const dispatchTime = parseTime(dispatch?.first ?? queueEntry?.dispatchTimestamp);
         const terminalTime = parseTime(terminal?.at);