@adhdev/daemon-core 0.9.82-rc.57 → 0.9.82-rc.59

package/dist/mesh/mesh-active-work.d.ts

@@ -0,0 +1,48 @@
+import type { MeshLedgerEntry } from './mesh-ledger.js';
+import type { MeshWorkQueueEntry } from './mesh-work-queue.js';
+export type MeshActiveWorkSource = 'queue' | 'direct';
+export type MeshActiveWorkStatus = 'pending' | 'assigned' | 'generating' | 'idle' | 'failed' | 'awaiting_approval';
+export interface MeshActiveWorkRecord {
+    taskId: string;
+    source: MeshActiveWorkSource;
+    status: MeshActiveWorkStatus;
+    nodeId?: string;
+    sessionId?: string;
+    providerType?: string;
+    taskTitle: string;
+    taskSummary: string;
+    message?: string;
+    taskMode?: string;
+    createdAt: string;
+    updatedAt: string;
+    dispatchedAt?: string;
+    elapsedMs: number;
+    terminal?: boolean;
+    terminalKind?: string;
+    terminalAt?: string;
+}
+export interface MeshActiveWorkSummary {
+    totalActiveCount: number;
+    queueActiveCount: number;
+    directActiveCount: number;
+    awaitingApprovalCount: number;
+    generatingCount: number;
+    failedCount: number;
+    idleCount: number;
+    sourceCounts: Record<MeshActiveWorkSource, number>;
+    statusCounts: Record<MeshActiveWorkStatus, number>;
+}
+export interface BuildMeshActiveWorkOptions {
+    meshId: string;
+    queue?: MeshWorkQueueEntry[];
+    ledgerEntries?: MeshLedgerEntry[];
+    nodes?: any[];
+    now?: number;
+    /** Include terminal direct rows (idle/failed) for handoff/recent-work surfaces. Defaults false. */
+    includeTerminalDirect?: boolean;
+}
+export declare function buildMeshActiveWorkSummary(activeWork: MeshActiveWorkRecord[]): MeshActiveWorkSummary;
+export declare function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): {
+    activeWork: MeshActiveWorkRecord[];
+    summary: MeshActiveWorkSummary;
+};

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

@@ -25,6 +25,40 @@ export interface MeshLedgerEntry {
     payload: Record<string, unknown>;
 }
 export declare function isIntentionalCleanupStopEntry(entry: Pick<MeshLedgerEntry, 'kind' | 'payload'>): boolean;
+export type MeshWorkerResultStatus = 'completed' | 'failed' | 'blocked' | 'partial' | 'unknown';
+export type MeshProcessArtifactKind = 'process' | 'log' | 'port' | 'window' | 'session' | 'file' | 'url' | 'other';
+export interface MeshValidationResultArtifact {
+    command?: string;
+    status: 'passed' | 'failed' | 'skipped' | 'unknown';
+    durationMs?: number;
+    outputPath?: string;
+    summary?: string;
+}
+export interface MeshProcessArtifact {
+    kind: MeshProcessArtifactKind;
+    id?: string;
+    label?: string;
+    locator?: string;
+    pid?: number;
+    port?: number;
+    url?: string;
+    path?: string;
+    sessionId?: string;
+    keepRunning?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface MeshWorkerResultArtifact {
+    status: MeshWorkerResultStatus;
+    classification?: string;
+    changedFiles: string[];
+    validationResults: MeshValidationResultArtifact[];
+    gitStatus?: Record<string, unknown>;
+    processArtifacts: MeshProcessArtifact[];
+    errors: string[];
+    nextAction?: string;
+    requiresUserAction: boolean;
+    source: 'explicit_metadata' | 'final_summary_json' | 'default';
+}
 export interface MeshTaskCompletionEvidence {
     source: 'agent_status_event';
     event: 'agent:generating_completed' | 'agent:ready';
@@ -38,6 +72,7 @@ export interface MeshTaskCompletionEvidence {
         providerSessionId?: string;
         finalSummaryAvailable: boolean;
     };
+    workerResult: MeshWorkerResultArtifact;
     git: {
         status: 'deferred';
         reason: string;
@@ -59,6 +94,7 @@ export interface BuildTaskCompletionEvidenceOptions {
     providerType?: string;
     providerSessionId?: string;
     finalSummary?: string;
+    workerResult?: Record<string, unknown>;
     completedAt?: string;
 }
 export interface MeshLedgerSummary {
@@ -115,6 +151,7 @@ export interface AppendRemoteLedgerResult {
 }
 export declare const MAX_LEDGER_SLICE_LIMIT = 500;
 export declare function getLedgerDir(): string;
+export declare function normalizeMeshWorkerResult(input?: Record<string, unknown>, source?: MeshWorkerResultArtifact['source']): MeshWorkerResultArtifact;
 export declare function buildTaskCompletionEvidence(opts: BuildTaskCompletionEvidenceOptions): MeshTaskCompletionEvidence;
 /**
  * Append a new entry to the mesh ledger.

package/dist/mesh/mesh-work-queue.d.ts

@@ -2,13 +2,24 @@ import type { RepoMeshDaemonRole } from '../repo-mesh-types.js';
 export type MeshTaskStatus = 'pending' | 'assigned' | 'completed' | 'failed' | 'cancelled';
 export type MeshActiveTaskStatus = Extract<MeshTaskStatus, 'pending' | 'assigned'>;
 export type MeshHistoricalTaskStatus = Extract<MeshTaskStatus, 'completed' | 'failed' | 'cancelled'>;
+export type MeshTaskMode = 'code_change' | 'validation' | 'live_debug_readonly' | 'launch_app' | 'convergence';
 export declare const ACTIVE_MESH_QUEUE_STATUSES: MeshActiveTaskStatus[];
 export declare const HISTORICAL_MESH_QUEUE_STATUSES: MeshHistoricalTaskStatus[];
+export declare const MESH_TASK_MODES: MeshTaskMode[];
+export interface MeshTaskModeValidationResult {
+    valid: boolean;
+    taskMode?: MeshTaskMode;
+    violations: string[];
+    allowedOperations?: string[];
+}
+export declare function normalizeMeshTaskMode(value: unknown): MeshTaskMode | undefined;
+export declare function validateMeshTaskModeRequest(mode: unknown, message: string): MeshTaskModeValidationResult;
 export interface MeshWorkQueueEntry {
     id: string;
     meshId: string;
     message: string;
     status: MeshTaskStatus;
+    taskMode?: MeshTaskMode;
     /** If specified, only this node can claim the task (used by legacy mesh_send_task) */
     targetNodeId?: string;
     /** If specified, only this runtime session can claim the task */
@@ -47,6 +58,7 @@ export interface MeshQueueMutationOptions {
 export declare function enqueueTask(meshId: string, message: string, opts?: {
     targetNodeId?: string;
     targetSessionId?: string;
+    taskMode?: MeshTaskMode | string;
 } & MeshQueueMutationOptions): MeshWorkQueueEntry;
 /**
  * Get all tasks in the queue, optionally filtered by status.

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

@@ -101,6 +101,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private completedDebouncePending;
     private enforceFreshSessionLaunchIfNeeded;
     private completionHasFinalAssistantMessage;
+    private buildCompletedFinalizationDiagnostic;
     private hasAdapterPendingResponse;
     private shouldSuppressStaleParsedBusyStatus;
     private getCompletedFinalizationBlockReason;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.57",
+  "version": "0.9.82-rc.59",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/cli-adapters/provider-cli-runtime.ts

@@ -36,7 +36,9 @@ export function resolveCliSpawnPlan(options: {
         : spawnConfig.command;
     const binaryPath = findBinary(configuredCommand);
     const isWin = os.platform() === 'win32';
-    const allArgs = [...spawnConfig.args, ...extraArgs];
+    const allArgs = [...spawnConfig.args, ...extraArgs].map((arg) =>
+        typeof arg === 'string' ? arg.replace(/\{\{workingDir\}\}/g, workingDir) : arg,
+    );
 
     let shellCmd: string;
     let shellArgs: string[];

package/src/commands/router.ts

@@ -460,6 +460,11 @@ function reconcileInlineMeshCache(cached: any, incoming: any): any {
     const incomingNodes = Array.isArray(incoming.nodes) ? incoming.nodes : [];
     if (!cachedNodes.length || !incomingNodes.length) return { ...cached, ...incoming };
 
+    const cachedUpdatedAt = Date.parse(readStringValue(cached.updatedAt, cached.updated_at) || '');
+    const incomingUpdatedAt = Date.parse(readStringValue(incoming.updatedAt, incoming.updated_at) || '');
+    const preserveCachedMembership = Number.isFinite(cachedUpdatedAt)
+        && (!Number.isFinite(incomingUpdatedAt) || cachedUpdatedAt > incomingUpdatedAt);
+
     const cachedById = new Map<string, any>();
     for (const node of cachedNodes) {
         const nodeId = readInlineMeshNodeId(node);
@@ -469,12 +474,13 @@ function reconcileInlineMeshCache(cached: any, incoming: any): any {
     const nodes = incomingNodes.map((incomingNode: any) => {
         const nodeId = readInlineMeshNodeId(incomingNode);
         const cachedNode = nodeId ? cachedById.get(nodeId) : undefined;
+        if (!cachedNode && preserveCachedMembership) return null;
         if (!cachedNode) return incomingNode;
         if (hasInlineMeshTransientNodeState(incomingNode)) {
             return { ...cachedNode, ...incomingNode };
         }
         return { ...stripInlineMeshTransientNodeState(cachedNode), ...incomingNode };
-    });
+    }).filter(Boolean);
 
     return {
         ...cached,

package/src/index.ts

@@ -178,16 +178,18 @@ export { syncMeshes } from './mesh/mesh-sync.js';
 export type { MeshSyncTransport, MeshSyncResult, RemoteMeshRecord } from './mesh/mesh-sync.js';
 
 // ── Mesh Task Ledger ──
-export { appendLedgerEntry, appendRemoteLedgerEntries, readLedgerEntries, readLedgerSlice, getLedgerSummary, getLedgerDir, getSessionRecoveryContext, MAX_LEDGER_SLICE_LIMIT } from './mesh/mesh-ledger.js';
-export type { AppendRemoteLedgerResult, MeshLedgerEntry, MeshLedgerKind, MeshLedgerSlice, MeshLedgerSummary, ReadLedgerOptions, ReadLedgerSliceOptions, SessionRecoveryContext } from './mesh/mesh-ledger.js';
+export { appendLedgerEntry, appendRemoteLedgerEntries, buildTaskCompletionEvidence, normalizeMeshWorkerResult, readLedgerEntries, readLedgerSlice, getLedgerSummary, getLedgerDir, getSessionRecoveryContext, MAX_LEDGER_SLICE_LIMIT } from './mesh/mesh-ledger.js';
+export type { AppendRemoteLedgerResult, MeshLedgerEntry, MeshLedgerKind, MeshLedgerSlice, MeshLedgerSummary, ReadLedgerOptions, ReadLedgerSliceOptions, SessionRecoveryContext, MeshTaskCompletionEvidence, MeshWorkerResultArtifact, MeshProcessArtifact, MeshValidationResultArtifact } from './mesh/mesh-ledger.js';
 export { fastForwardMeshNode } from './mesh/mesh-fast-forward.js';
 export type { MeshFastForwardNodeArgs, MeshFastForwardPlannedStep, MeshFastForwardResult } from './mesh/mesh-fast-forward.js';
 export { buildMeshLedgerReconciliationEvidence, buildMeshLedgerReplicaEvidence } from './mesh/mesh-ledger-reconciliation.js';
 export type { MeshLedgerReconciliationEvidence, MeshLedgerReplicaEvidence, MeshLedgerReplicaStatus } from './mesh/mesh-ledger-reconciliation.js';
 
 // ── Mesh Work Queue (GUPP) ──
-export { enqueueTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats } from './mesh/mesh-work-queue.js';
-export type { MeshWorkQueueEntry, MeshTaskStatus, MeshWorkQueueStats, MeshQueueMutationOptions } from './mesh/mesh-work-queue.js';
+export { enqueueTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats, normalizeMeshTaskMode, validateMeshTaskModeRequest } from './mesh/mesh-work-queue.js';
+export type { MeshWorkQueueEntry, MeshTaskStatus, MeshTaskMode, MeshWorkQueueStats, MeshQueueMutationOptions, MeshTaskModeValidationResult } from './mesh/mesh-work-queue.js';
+export { buildMeshActiveWork, buildMeshActiveWorkSummary } from './mesh/mesh-active-work.js';
+export type { MeshActiveWorkRecord, MeshActiveWorkStatus, MeshActiveWorkSummary, MeshActiveWorkSource } from './mesh/mesh-active-work.js';
 
 // ── Mesh Host Ownership ──
 export { buildMeshHostRequiredFailure, createDefaultMeshHostMetadata, isMeshHostOwner, normalizeMeshDaemonRole, requireMeshHostQueueOwner, resolveMeshHostStatus } from './mesh/mesh-host-ownership.js';

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

@@ -0,0 +1,205 @@
+import type { MeshLedgerEntry } from './mesh-ledger.js';
+import type { MeshWorkQueueEntry } from './mesh-work-queue.js';
+
+export type MeshActiveWorkSource = 'queue' | 'direct';
+export type MeshActiveWorkStatus = 'pending' | 'assigned' | 'generating' | 'idle' | 'failed' | 'awaiting_approval';
+
+export interface MeshActiveWorkRecord {
+    taskId: string;
+    source: MeshActiveWorkSource;
+    status: MeshActiveWorkStatus;
+    nodeId?: string;
+    sessionId?: string;
+    providerType?: string;
+    taskTitle: string;
+    taskSummary: string;
+    message?: string;
+    taskMode?: string;
+    createdAt: string;
+    updatedAt: string;
+    dispatchedAt?: string;
+    elapsedMs: number;
+    terminal?: boolean;
+    terminalKind?: string;
+    terminalAt?: string;
+}
+
+export interface MeshActiveWorkSummary {
+    totalActiveCount: number;
+    queueActiveCount: number;
+    directActiveCount: number;
+    awaitingApprovalCount: number;
+    generatingCount: number;
+    failedCount: number;
+    idleCount: number;
+    sourceCounts: Record<MeshActiveWorkSource, number>;
+    statusCounts: Record<MeshActiveWorkStatus, number>;
+}
+
+export interface BuildMeshActiveWorkOptions {
+    meshId: string;
+    queue?: MeshWorkQueueEntry[];
+    ledgerEntries?: MeshLedgerEntry[];
+    nodes?: any[];
+    now?: number;
+    /** Include terminal direct rows (idle/failed) for handoff/recent-work surfaces. Defaults false. */
+    includeTerminalDirect?: boolean;
+}
+
+const DIRECT_DISPATCH_VIA = new Set(['p2p_direct', 'local_direct', 'mesh_send_task']);
+const TERMINAL_LEDGER_KINDS = new Set(['task_completed', 'task_failed', 'task_stalled']);
+
+function readString(value: unknown): string | undefined {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function summarizeMessage(message: string): { title: string; summary: string } {
+    const oneLine = message.replace(/\s+/g, ' ').trim();
+    const title = oneLine.length > 96 ? `${oneLine.slice(0, 93)}...` : oneLine;
+    return { title: title || '(untitled task)', summary: oneLine };
+}
+
+function elapsedSince(value: string | undefined, now: number): number {
+    const started = value ? new Date(value).getTime() : Number.NaN;
+    return Number.isFinite(started) ? Math.max(0, now - started) : 0;
+}
+
+function sessionStatusFromNodes(nodes: any[] | undefined, nodeId?: string, sessionId?: string): MeshActiveWorkStatus | undefined {
+    if (!nodeId || !sessionId || !Array.isArray(nodes)) return undefined;
+    const node = nodes.find(item => readString(item?.id) === nodeId || readString(item?.nodeId) === nodeId || readString(item?.node_id) === nodeId);
+    if (!node) return undefined;
+    const candidates: any[] = [];
+    for (const value of [node.sessions, node.activeSessions, node.active_sessions, node.lastProbe?.sessions, node.last_probe?.sessions, node.lastProbe?.status?.sessions, node.last_probe?.status?.sessions]) {
+        if (Array.isArray(value)) candidates.push(...value);
+    }
+    for (const value of [node.activeSession, node.active_session, node.currentSession, node.current_session, node.runtimeSession, node.runtime_session, node.session]) {
+        if (value && typeof value === 'object') candidates.push(value);
+    }
+    const session = candidates.find(item => {
+        const id = readString(item?.id) || readString(item?.sessionId) || readString(item?.session_id) || readString(item?.runtimeSessionId) || readString(item?.instanceId);
+        return id === sessionId;
+    });
+    if (!session) return undefined;
+    const raw = `${readString(session.status) || ''} ${readString(session.lifecycle) || ''} ${readString(session.state) || ''} ${readString(session.activeChat?.status) || ''}`.toLowerCase();
+    if (raw.includes('approval')) return 'awaiting_approval';
+    if (raw.includes('generating') || raw.includes('running') || raw.includes('busy')) return 'generating';
+    if (raw.includes('failed') || raw.includes('stopped') || raw.includes('terminated') || raw.includes('exited')) return 'failed';
+    if (raw.includes('idle') || raw.includes('waiting_input') || raw.includes('ready')) return 'idle';
+    return undefined;
+}
+
+function isDirectDispatch(entry: MeshLedgerEntry): boolean {
+    if (entry.kind !== 'task_dispatched') return false;
+    const payload = entry.payload || {};
+    if (payload.source === 'direct') return true;
+    const via = readString(payload.via);
+    return Boolean(via && DIRECT_DISPATCH_VIA.has(via) && payload.source !== 'queue');
+}
+
+function directDispatchTaskId(entry: MeshLedgerEntry): string {
+    return readString(entry.payload?.taskId) || entry.id;
+}
+
+function terminalMatchesDispatch(terminal: MeshLedgerEntry, dispatch: MeshLedgerEntry, taskId: string): boolean {
+    const terminalTaskId = readString(terminal.payload?.taskId);
+    if (terminalTaskId && terminalTaskId === taskId) return true;
+    if (terminalTaskId && terminalTaskId !== taskId) return false;
+    if (dispatch.sessionId && terminal.sessionId === dispatch.sessionId) return true;
+    return Boolean(dispatch.nodeId && terminal.nodeId === dispatch.nodeId && !dispatch.sessionId);
+}
+
+function statusFromTerminal(entry: MeshLedgerEntry): MeshActiveWorkStatus {
+    if (entry.kind === 'task_approval_needed') return 'awaiting_approval';
+    if (entry.kind === 'task_completed') return 'idle';
+    return 'failed';
+}
+
+export function buildMeshActiveWorkSummary(activeWork: MeshActiveWorkRecord[]): MeshActiveWorkSummary {
+    const statusCounts: Record<MeshActiveWorkStatus, number> = {
+        pending: 0,
+        assigned: 0,
+        generating: 0,
+        idle: 0,
+        failed: 0,
+        awaiting_approval: 0,
+    };
+    const sourceCounts: Record<MeshActiveWorkSource, number> = { queue: 0, direct: 0 };
+    for (const item of activeWork) {
+        sourceCounts[item.source] += 1;
+        statusCounts[item.status] += 1;
+    }
+    return {
+        totalActiveCount: activeWork.length,
+        queueActiveCount: sourceCounts.queue,
+        directActiveCount: sourceCounts.direct,
+        awaitingApprovalCount: statusCounts.awaiting_approval,
+        generatingCount: statusCounts.generating,
+        failedCount: statusCounts.failed,
+        idleCount: statusCounts.idle,
+        sourceCounts,
+        statusCounts,
+    };
+}
+
+export function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): { activeWork: MeshActiveWorkRecord[]; summary: MeshActiveWorkSummary } {
+    const now = opts.now ?? Date.now();
+    const records: MeshActiveWorkRecord[] = [];
+
+    for (const task of opts.queue || []) {
+        if (task.status !== 'pending' && task.status !== 'assigned') continue;
+        const { title, summary } = summarizeMessage(task.message || '');
+        records.push({
+            taskId: task.id,
+            source: 'queue',
+            status: task.status,
+            nodeId: task.assignedNodeId || task.targetNodeId,
+            sessionId: task.assignedSessionId || task.targetSessionId,
+            taskTitle: title,
+            taskSummary: summary,
+            message: task.message,
+            taskMode: task.taskMode,
+            createdAt: task.createdAt,
+            updatedAt: task.updatedAt,
+            dispatchedAt: task.dispatchTimestamp,
+            elapsedMs: elapsedSince(task.dispatchTimestamp || task.createdAt, now),
+        });
+    }
+
+    const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    const terminals = ledgerEntries.filter(entry => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === 'task_approval_needed');
+    for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {
+        const taskId = directDispatchTaskId(dispatch);
+        const terminal = terminals
+            .filter(entry => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime())
+            .find(entry => terminalMatchesDispatch(entry, dispatch, taskId));
+        const terminalStatus = terminal ? statusFromTerminal(terminal) : undefined;
+        const liveStatus = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
+        const status = terminalStatus || liveStatus || 'assigned';
+        const terminalRow = Boolean(terminal && terminal.kind !== 'task_approval_needed');
+        if (terminalRow && opts.includeTerminalDirect !== true) continue;
+        const message = readString(dispatch.payload?.message) || readString(dispatch.payload?.summary) || '';
+        const { title, summary } = summarizeMessage(message);
+        records.push({
+            taskId,
+            source: 'direct',
+            status,
+            nodeId: dispatch.nodeId,
+            sessionId: dispatch.sessionId,
+            providerType: dispatch.providerType || readString(dispatch.payload?.providerType),
+            taskTitle: readString(dispatch.payload?.taskTitle) || title,
+            taskSummary: readString(dispatch.payload?.taskSummary) || summary,
+            message,
+            taskMode: readString(dispatch.payload?.taskMode),
+            createdAt: dispatch.timestamp,
+            updatedAt: terminal?.timestamp || dispatch.timestamp,
+            dispatchedAt: dispatch.timestamp,
+            elapsedMs: elapsedSince(dispatch.timestamp, now),
+            terminal: terminalRow,
+            terminalKind: terminal?.kind,
+            terminalAt: terminal?.timestamp,
+        });
+    }
+
+    records.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+    return { activeWork: records, summary: buildMeshActiveWorkSummary(records) };
+}

package/src/mesh/mesh-events.ts

@@ -25,6 +25,10 @@ interface RemoteIdleSession {
 const REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1000; // 5 minutes
 const remoteIdleSessions = new Map<string, RemoteIdleSession>(); // key: `${nodeId}:${sessionId}`
 
+function readWorkerResultMetadata(event: Record<string, unknown>): Record<string, unknown> | undefined {
+    return readRecord(event.workerResult) || readRecord(event.meshWorkerResult) || readRecord(event.structuredResult);
+}
+
 function sweepExpiredRemoteIdleSessions(): void {
     const now = Date.now();
     for (const [key, session] of remoteIdleSessions) {
@@ -107,6 +111,12 @@ function readNonEmptyString(value: unknown): string {
     return typeof value === 'string' && value.trim() ? value.trim() : '';
 }
 
+function readRecord(value: unknown): Record<string, unknown> | undefined {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value as Record<string, unknown>
+        : undefined;
+}
+
 function resolveEventSessionId(event: Record<string, unknown>, fallback?: unknown): string {
     return readNonEmptyString(event.targetSessionId)
         || readNonEmptyString(event.sessionId)
@@ -135,10 +145,21 @@ function isMeshCoordinatorEvent(eventName: unknown): eventName is string {
 }
 
 function formatCompletionMetadata(event: Record<string, unknown>): string {
+    const completionDiagnostic = event.completionDiagnostic && typeof event.completionDiagnostic === 'object'
+        ? event.completionDiagnostic as Record<string, unknown>
+        : null;
+    const diagnosticReason = completionDiagnostic
+        ? readNonEmptyString(completionDiagnostic.blockReason) || 'present'
+        : '';
+    const finalAssistantPresent = typeof completionDiagnostic?.finalAssistantPresent === 'boolean'
+        ? String(completionDiagnostic.finalAssistantPresent)
+        : '';
     const parts = [
         readNonEmptyString(event.targetSessionId) ? `session_id=${readNonEmptyString(event.targetSessionId)}` : '',
         readNonEmptyString(event.providerType) ? `provider=${readNonEmptyString(event.providerType)}` : '',
         readNonEmptyString(event.providerSessionId) ? `provider_session_id=${readNonEmptyString(event.providerSessionId)}` : '',
+        diagnosticReason ? `completion_diagnostic=${diagnosticReason}` : '',
+        finalAssistantPresent ? `final_assistant=${finalAssistantPresent}` : '',
     ].filter(Boolean);
     return parts.length > 0 ? ` (${parts.join('; ')})` : '';
 }
@@ -748,6 +769,9 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
         const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
         const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
         const providerType = readNonEmptyString(args.metadataEvent.providerType);
+        const providerSessionId = readNonEmptyString(args.metadataEvent.providerSessionId) || undefined;
+        const finalSummary = readNonEmptyString(args.metadataEvent.finalSummary) || undefined;
+        const workerResult = readWorkerResultMetadata(args.metadataEvent);
         const completedTask = sessionId
             ? updateSessionTaskStatus(args.meshId, sessionId, 'completed')
             : null;
@@ -764,15 +788,17 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                         nodeLabel: args.nodeLabel,
                         taskId: completedTask.id,
                         completedViaReady: true,
-                        providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || undefined,
-                        finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
+                        providerSessionId,
+                        finalSummary,
+                        workerResult,
                         evidence: buildTaskCompletionEvidence({
                             event: 'agent:ready',
                             nodeId,
                             sessionId,
                             providerType: providerType || undefined,
-                            providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || undefined,
-                            finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
+                            providerSessionId,
+                            finalSummary,
+                            workerResult,
                         }),
                     },
                 });
@@ -815,14 +841,18 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             const ledgerNodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || undefined;
             const ledgerSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId) || undefined;
             const ledgerProviderType = readNonEmptyString(args.metadataEvent.providerType) || undefined;
+            const providerSessionId = readNonEmptyString(args.metadataEvent.providerSessionId) || undefined;
+            const finalSummary = readNonEmptyString(args.metadataEvent.finalSummary) || undefined;
+            const workerResult = readWorkerResultMetadata(args.metadataEvent);
             const completionEvidence = ledgerKind === 'task_completed' && ledgerNodeId && ledgerSessionId
                 ? buildTaskCompletionEvidence({
                     event: 'agent:generating_completed',
                     nodeId: ledgerNodeId,
                     sessionId: ledgerSessionId,
                     providerType: ledgerProviderType,
-                    providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || undefined,
-                    finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
+                    providerSessionId,
+                    finalSummary,
+                    workerResult,
                 })
                 : undefined;
             appendLedgerEntry(args.meshId, {
@@ -834,8 +864,12 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
                     event: args.event,
                     nodeLabel: args.nodeLabel,
                     taskId: completedTaskForLedger?.id || undefined,
-                    providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || undefined,
-                    finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || undefined,
+                    providerSessionId,
+                    finalSummary,
+                    workerResult,
+                    completionDiagnostic: args.metadataEvent.completionDiagnostic && typeof args.metadataEvent.completionDiagnostic === 'object'
+                        ? args.metadataEvent.completionDiagnostic
+                        : undefined,
                     evidence: completionEvidence,
                 },
             });