@adhdev/daemon-core 0.9.82-rc.21 → 0.9.82-rc.211

package/src/mesh/mesh-missions.ts

@@ -0,0 +1,151 @@
+/**
+ * M3: Mission persistence (minimal form).
+ *
+ * A mission is a persistent record of a multi-task goal so the plan lives in
+ * the system rather than in the coordinator LLM's context. Coordinator
+ * sessions can die or compact; a new coordinator reads the mission back at
+ * launch and continues.
+ *
+ * Explicit non-goals (see docs/mesh-product-plan-v2.md Phase M3): this is not
+ * a workflow engine and there is no automatic takeover daemon. Progress is
+ * never stored — it is derived from queue task statuses (mission_id) at
+ * query time.
+ */
+
+import { randomUUID } from 'crypto';
+import { MeshRuntimeStore } from './mesh-runtime-store.js';
+import { getQueue } from './mesh-work-queue.js';
+
+export type MeshMissionStatus = 'active' | 'paused' | 'completed' | 'abandoned';
+
+export const MESH_MISSION_STATUSES: MeshMissionStatus[] = ['active', 'paused', 'completed', 'abandoned'];
+
+export interface MeshMissionRecord {
+    id: string;
+    meshId: string;
+    title: string;
+    goal: string;
+    status: MeshMissionStatus;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export interface MeshMissionTaskAggregate {
+    total: number;
+    pending: number;
+    assigned: number;
+    completed: number;
+    failed: number;
+    cancelled: number;
+    /** Pending tasks held back by a dependency failure (blockedReason set). */
+    blocked: number;
+    /** Latest updatedAt across the mission's tasks, or null with no tasks. */
+    lastActivityAt: string | null;
+}
+
+export interface MeshMissionSummary extends MeshMissionRecord {
+    tasks: MeshMissionTaskAggregate;
+}
+
+function normalizeMissionStatus(value: unknown): MeshMissionStatus {
+    return MESH_MISSION_STATUSES.includes(value as MeshMissionStatus)
+        ? value as MeshMissionStatus
+        : 'active';
+}
+
+export function upsertMeshMission(meshId: string, input: {
+    id?: string;
+    title: string;
+    goal?: string;
+    status?: string;
+}): MeshMissionRecord {
+    const title = typeof input.title === 'string' ? input.title.trim() : '';
+    if (!title) throw new Error('mission_title_required: a mission needs a non-empty title');
+    if (input.status !== undefined && !MESH_MISSION_STATUSES.includes(input.status as MeshMissionStatus)) {
+        throw new Error(`invalid_mission_status: '${input.status}' (valid: ${MESH_MISSION_STATUSES.join(', ')})`);
+    }
+    const id = typeof input.id === 'string' && input.id.trim() ? input.id.trim() : randomUUID();
+    const store = MeshRuntimeStore.getInstance();
+    const existing = store.getMission(meshId, id);
+    const record = {
+        id,
+        meshId,
+        title,
+        goal: typeof input.goal === 'string' ? input.goal : existing?.goal ?? '',
+        status: normalizeMissionStatus(input.status ?? existing?.status),
+    };
+    store.upsertMission(record);
+    const saved = store.getMission(meshId, id)!;
+    return { ...saved, status: normalizeMissionStatus(saved.status) };
+}
+
+export function getMeshMissions(meshId: string, statuses?: MeshMissionStatus[]): MeshMissionRecord[] {
+    return MeshRuntimeStore.getInstance().getMissions(meshId, statuses)
+        .map(m => ({ ...m, status: normalizeMissionStatus(m.status) }));
+}
+
+export function getMeshMission(meshId: string, missionId: string): MeshMissionRecord | null {
+    const record = MeshRuntimeStore.getInstance().getMission(meshId, missionId);
+    return record ? { ...record, status: normalizeMissionStatus(record.status) } : null;
+}
+
+/** Aggregate task statuses for a mission at query time (no stored progress). */
+export function summarizeMissionTasks(meshId: string, missionId: string): MeshMissionTaskAggregate {
+    const tasks = getQueue(meshId).filter(task => task.missionId === missionId);
+    const aggregate: MeshMissionTaskAggregate = {
+        total: tasks.length,
+        pending: 0,
+        assigned: 0,
+        completed: 0,
+        failed: 0,
+        cancelled: 0,
+        blocked: 0,
+        lastActivityAt: null,
+    };
+    for (const task of tasks) {
+        if (task.status === 'pending') aggregate.pending += 1;
+        else if (task.status === 'assigned') aggregate.assigned += 1;
+        else if (task.status === 'completed') aggregate.completed += 1;
+        else if (task.status === 'failed') aggregate.failed += 1;
+        else if (task.status === 'cancelled') aggregate.cancelled += 1;
+        if (task.status === 'pending' && task.blockedReason) aggregate.blocked += 1;
+        if (task.updatedAt && (!aggregate.lastActivityAt || task.updatedAt > aggregate.lastActivityAt)) {
+            aggregate.lastActivityAt = task.updatedAt;
+        }
+    }
+    return aggregate;
+}
+
+export function summarizeMeshMission(meshId: string, mission: MeshMissionRecord): MeshMissionSummary {
+    return { ...mission, tasks: summarizeMissionTasks(meshId, mission.id) };
+}
+
+/** Active mission summaries for mesh_status / coordinator prompt injection. */
+export function getActiveMeshMissionSummaries(meshId: string): MeshMissionSummary[] {
+    return getMeshMissions(meshId, ['active']).map(mission => summarizeMeshMission(meshId, mission));
+}
+
+/**
+ * M3-3: render active missions as a prompt section for {{mission}}.
+ * Empty string when no active mission — the prompt stays byte-identical to
+ * the pre-M3 output in that case (regression guarantee).
+ */
+export function buildMissionPromptSection(meshId: string): string {
+    const summaries = getActiveMeshMissionSummaries(meshId);
+    if (summaries.length === 0) return '';
+    const lines: string[] = ['## Active Mission' + (summaries.length > 1 ? 's' : '')];
+    for (const mission of summaries) {
+        const t = mission.tasks;
+        lines.push(
+            `- **${mission.title}** (id: \`${mission.id}\`)`
+            + (mission.goal ? `\n  Goal: ${mission.goal}` : '')
+            + `\n  Tasks: ${t.total} total — ${t.pending} pending (${t.blocked} blocked), ${t.assigned} assigned, ${t.completed} completed, ${t.failed} failed, ${t.cancelled} cancelled`
+            + (t.lastActivityAt ? `\n  Last activity: ${t.lastActivityAt}` : ''),
+        );
+    }
+    lines.push(
+        'Continue this mission from its current task state. Do not re-enqueue tasks that already exist — check mesh_view_queue first. '
+        + 'Update the mission with mesh_mission_upsert when its goal changes or it reaches a terminal state (completed/abandoned).',
+    );
+    return lines.join('\n');
+}

package/src/mesh/mesh-refine-status.ts

@@ -0,0 +1,144 @@
+import type { MeshLedgerEntry } from './mesh-ledger.js';
+import type { PendingMeshCoordinatorEvent } from './mesh-events.js';
+import type { MeshAsyncJobLifecycle } from '../repo-mesh-types.js';
+
+export type MeshAsyncRefineJobStatus = 'accepted' | 'running' | 'completed' | 'failed';
+
+export interface MeshAsyncRefineJobSummary extends MeshAsyncJobLifecycle {
+    jobId: string;
+    interactionId?: string;
+    status: MeshAsyncRefineJobStatus;
+    meshId?: string;
+    nodeId?: string;
+    targetNodeId?: string;
+    targetDaemonId?: string;
+    workspace?: string;
+    branch?: string;
+    into?: string;
+    retryOfJobId?: string;
+    lastEvent?: string;
+    lastLedgerKind?: string;
+    lastUpdatedAt?: string;
+    instruction: string;
+}
+
+function readString(value: unknown): string | undefined {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function readRecord(value: unknown): Record<string, unknown> | undefined {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value as Record<string, unknown>
+        : undefined;
+}
+
+function eventStatus(event: string | undefined, fallback?: string): MeshAsyncRefineJobStatus | undefined {
+    if (event === 'refine:accepted') return 'accepted';
+    if (event === 'refine:completed') return 'completed';
+    if (event === 'refine:failed') return 'failed';
+    if (fallback === 'completed' || fallback === 'failed' || fallback === 'accepted') return fallback;
+    return undefined;
+}
+
+function ledgerStatus(kind: string, fallback?: string): MeshAsyncRefineJobStatus {
+    if (kind === 'task_completed') return 'completed';
+    if (kind === 'task_failed') return 'failed';
+    if (fallback === 'accepted') return 'accepted';
+    return 'running';
+}
+
+function instructionForStatus(status: MeshAsyncRefineJobStatus): string {
+    if (status === 'accepted') return 'Refine job is accepted; wait for asyncRefineJobs or pendingCoordinatorEvents to report running/completed/failed.';
+    if (status === 'running') return 'Refine job is running; do not poll the ledger repeatedly. Watch asyncRefineJobs or pendingCoordinatorEvents for the terminal result.';
+    if (status === 'completed') return 'Refine job completed; inspect branch convergence and cleanup evidence before reporting final merge state.';
+    return 'Refine job failed; inspect result/finalBranchConvergenceState in mesh_task_history, fix the blocker, then rerun mesh_refine_node when ready.';
+}
+
+function mergeJob(
+    jobs: Map<string, MeshAsyncRefineJobSummary>,
+    patch: Partial<MeshAsyncRefineJobSummary> & { jobId?: string },
+): void {
+    const jobId = readString(patch.jobId);
+    if (!jobId) return;
+    const previous = jobs.get(jobId);
+    const status = patch.status || previous?.status || 'running';
+    const definedPatch = Object.fromEntries(
+        Object.entries(patch).filter(([, value]) => value !== undefined),
+    ) as Partial<MeshAsyncRefineJobSummary>;
+    jobs.set(jobId, {
+        ...previous,
+        ...definedPatch,
+        jobId,
+        status,
+        instruction: instructionForStatus(status),
+    });
+}
+
+export function buildMeshAsyncRefineJobs(args: {
+    meshId?: string;
+    ledgerEntries?: MeshLedgerEntry[];
+    pendingEvents?: PendingMeshCoordinatorEvent[];
+}): MeshAsyncRefineJobSummary[] {
+    const jobs = new Map<string, MeshAsyncRefineJobSummary>();
+
+    for (const entry of args.ledgerEntries || []) {
+        const payload = readRecord(entry.payload);
+        if (payload?.source !== 'refine_mesh_node_async_job') continue;
+        const refineJob = readRecord(payload.refineJob);
+        const result = readRecord(payload.result);
+        const finalState = readRecord(payload.finalBranchConvergenceState) || readRecord(result?.finalBranchConvergenceState);
+        const jobId = readString(refineJob?.jobId);
+        if (!jobId) continue;
+        const status = ledgerStatus(entry.kind, readString(refineJob?.status));
+        mergeJob(jobs, {
+            jobId,
+            interactionId: readString(refineJob?.interactionId),
+            status,
+            meshId: readString(refineJob?.meshId) || args.meshId,
+            nodeId: readString(refineJob?.nodeId) || entry.nodeId,
+            targetNodeId: readString(refineJob?.nodeId) || entry.nodeId,
+            targetDaemonId: readString(refineJob?.targetDaemonId),
+            workspace: readString(refineJob?.workspace),
+            branch: readString(result?.branch) || readString(finalState?.branch),
+            into: readString(result?.into) || readString(finalState?.baseBranch),
+            startedAt: readString(refineJob?.startedAt),
+            completedAt: readString(refineJob?.completedAt),
+            retryOfJobId: readString(refineJob?.retryOfJobId) || readString(payload.retryOfJobId),
+            lastLedgerKind: entry.kind,
+            lastUpdatedAt: entry.timestamp,
+        });
+    }
+
+    for (const event of args.pendingEvents || []) {
+        const metadata = readRecord(event.metadataEvent);
+        if (metadata?.source !== 'refine_mesh_node_async_job') continue;
+        const result = readRecord(metadata.result);
+        const finalState = readRecord(result?.finalBranchConvergenceState);
+        const jobId = readString(metadata.jobId);
+        if (!jobId) continue;
+        const status = eventStatus(event.event, readString(metadata.status));
+        mergeJob(jobs, {
+            jobId,
+            interactionId: readString(metadata.interactionId),
+            ...(status ? { status } : {}),
+            meshId: readString(metadata.meshId) || event.meshId || args.meshId,
+            nodeId: readString(metadata.nodeId) || event.nodeId,
+            targetNodeId: readString(metadata.nodeId) || event.nodeId,
+            targetDaemonId: readString(metadata.targetDaemonId),
+            workspace: readString(metadata.workspace) || event.workspace,
+            branch: readString(result?.branch) || readString(finalState?.branch),
+            into: readString(result?.into) || readString(finalState?.baseBranch),
+            startedAt: readString(metadata.startedAt),
+            completedAt: readString(metadata.completedAt),
+            retryOfJobId: readString(metadata.retryOfJobId),
+            lastEvent: event.event,
+            lastUpdatedAt: new Date(event.queuedAt).toISOString(),
+        });
+    }
+
+    return Array.from(jobs.values()).sort((a, b) => {
+        const aTime = new Date(a.lastUpdatedAt || a.startedAt || '').getTime();
+        const bTime = new Date(b.lastUpdatedAt || b.startedAt || '').getTime();
+        return (Number.isFinite(bTime) ? bTime : 0) - (Number.isFinite(aTime) ? aTime : 0);
+    });
+}

package/src/mesh/mesh-review-inbox.ts

@@ -0,0 +1,307 @@
+/**
+ * M4.0: Review inbox — derive review items from existing truth.
+ *
+ * No new store: review items are a query-time projection of
+ *   - mesh_status node statuses (daemon-owned branchConvergence), and
+ *   - the task ledger (completion evidence envelopes + refine job results).
+ *
+ * Scope (M4.0): host-daemon-local nodes only. Remote nodes are excluded and
+ * surfaced via remoteNodesExcluded/excludedRemoteNodeIds until the
+ * daemon↔daemon P2P relay path is live-verified (M4.2).
+ */
+
+import type { MeshLedgerEntry } from './mesh-ledger.js';
+import { buildMeshAsyncRefineJobs } from './mesh-refine-status.js';
+
+export type MeshReviewInboxReason = 'merge_candidate' | 'refine_blocked_review';
+
+export interface MeshReviewInboxConvergence {
+    status: string;
+    reason: string | null;
+    nextStep: string | null;
+    needsConvergence: boolean;
+}
+
+export interface MeshReviewInboxEvidence {
+    available: boolean;
+    /** Ledger kind of the entry the evidence came from. */
+    kind?: 'task_completed' | 'task_failed';
+    /** 'task_completion' = ordinary worker completion envelope; 'refine_job' = Refinery result. */
+    source?: 'task_completion' | 'refine_job';
+    timestamp?: string;
+    taskId?: string;
+    sessionId?: string;
+    /** M2-3 bootstrap stage from the refine validation gate: cached|ran|failed|skipped|legacy|not_configured. */
+    bootstrap?: Record<string, unknown> | null;
+    validation?: Record<string, unknown> | null;
+    checkpoint?: Record<string, unknown> | null;
+    worker?: {
+        status: string;
+        classification?: string;
+        changedFiles: string[];
+        changedFilesTruncated?: true;
+        validationResults: Array<Record<string, unknown>>;
+        errors: string[];
+        requiresUserAction: boolean;
+    } | null;
+    finalBranchConvergenceState?: Record<string, unknown>;
+    refineJob?: Record<string, unknown>;
+}
+
+export interface MeshReviewInboxDiffFile {
+    path: string;
+    status?: string;
+    insertions?: number;
+    deletions?: number;
+    binary?: boolean;
+    oldPath?: string;
+}
+
+export interface MeshReviewInboxDiffSummary {
+    baseRef: string;
+    files: MeshReviewInboxDiffFile[];
+    totalFiles: number;
+    totalInsertions: number;
+    totalDeletions: number;
+    truncated: boolean;
+    error?: string;
+}
+
+export interface MeshReviewInboxItem {
+    nodeId: string;
+    workspace: string | null;
+    branch: string | null;
+    defaultBranch: string | null;
+    isLocalWorktree: boolean;
+    reviewReason: MeshReviewInboxReason;
+    convergence: MeshReviewInboxConvergence;
+    evidence: MeshReviewInboxEvidence;
+    transcriptHandle: Record<string, unknown> | null;
+    /** Latest non-terminal Refinery job for this node (accepted/running), if any. */
+    activeRefineJob: Record<string, unknown> | null;
+    lastActivityAt: string | null;
+    /** Filled by the daemon command with a bounded base-branch diff probe; null when the workspace is not locally readable. */
+    diffSummary?: MeshReviewInboxDiffSummary | null;
+}
+
+export interface MeshReviewInboxDerivation {
+    items: MeshReviewInboxItem[];
+    remoteNodesExcluded: boolean;
+    excludedRemoteNodeIds: string[];
+}
+
+const MAX_CHANGED_FILES = 100;
+
+function readString(value: unknown): string | null {
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
+function readRecord(value: unknown): Record<string, unknown> | null {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value as Record<string, unknown>
+        : null;
+}
+
+function readStringArray(value: unknown, max: number): { values: string[]; truncated: boolean } {
+    if (!Array.isArray(value)) return { values: [], truncated: false };
+    const values = value.filter((item): item is string => typeof item === 'string' && item.trim().length > 0);
+    return { values: values.slice(0, max), truncated: values.length > max };
+}
+
+function isLocalNodeStatus(node: Record<string, unknown>): boolean {
+    if (node.isLocalWorktree === true) return true;
+    const connection = readRecord(node.connection);
+    return readString(connection?.state) === 'self';
+}
+
+function readNodeConvergence(node: Record<string, unknown>): (MeshReviewInboxConvergence & { branch: string | null; defaultBranch: string | null }) | null {
+    const convergence = readRecord(node.branchConvergence);
+    const status = readString(convergence?.status);
+    if (!convergence || !status) return null;
+    return {
+        status,
+        reason: readString(convergence.reason),
+        nextStep: readString(convergence.nextStep),
+        needsConvergence: convergence.needsConvergence === true,
+        branch: readString(convergence.branch),
+        defaultBranch: readString(convergence.defaultBranch),
+    };
+}
+
+function isMergeCandidate(convergence: MeshReviewInboxConvergence): boolean {
+    if (convergence.status === 'pushed_feature_branch_needs_merge') return true;
+    // Clean non-default worktree branch — the local merge candidate shape
+    // (router classifies it cleanup_candidate with this reason).
+    return convergence.status === 'cleanup_candidate'
+        && convergence.reason === 'clean_non_default_worktree_branch';
+}
+
+function readWorkerArtifact(value: unknown): MeshReviewInboxEvidence['worker'] {
+    const worker = readRecord(value);
+    if (!worker) return null;
+    const changed = readStringArray(worker.changedFiles, MAX_CHANGED_FILES);
+    return {
+        status: readString(worker.status) ?? 'unknown',
+        ...(readString(worker.classification) ? { classification: readString(worker.classification)! } : {}),
+        changedFiles: changed.values,
+        ...(changed.truncated ? { changedFilesTruncated: true as const } : {}),
+        validationResults: Array.isArray(worker.validationResults)
+            ? worker.validationResults.map(item => readRecord(item)).filter((item): item is Record<string, unknown> => item !== null)
+            : [],
+        errors: readStringArray(worker.errors, 20).values,
+        requiresUserAction: worker.requiresUserAction === true,
+    };
+}
+
+function isTerminalLedgerKind(kind: string): kind is 'task_completed' | 'task_failed' {
+    return kind === 'task_completed' || kind === 'task_failed';
+}
+
+/**
+ * Latest terminal evidence for a node, normalized into the review card shape.
+ * Refine job entries carry the validation gate summary (incl. the M2-3
+ * bootstrap stage); ordinary completions carry the B-series evidence envelope.
+ */
+function resolveNodeEvidence(nodeId: string, ledgerEntries: MeshLedgerEntry[]): {
+    evidence: MeshReviewInboxEvidence;
+    transcriptHandle: Record<string, unknown> | null;
+} {
+    let evidence: MeshReviewInboxEvidence = { available: false };
+    let transcriptHandle: Record<string, unknown> | null = null;
+
+    for (let i = ledgerEntries.length - 1; i >= 0; i--) {
+        const entry = ledgerEntries[i];
+        if (entry.nodeId !== nodeId || !isTerminalLedgerKind(entry.kind)) continue;
+        const payload = readRecord(entry.payload) ?? {};
+
+        if (!evidence.available) {
+            if (payload.source === 'refine_mesh_node_async_job') {
+                const result = readRecord(payload.result);
+                const validationSummary = readRecord(result?.validationSummary);
+                evidence = {
+                    available: true,
+                    kind: entry.kind,
+                    source: 'refine_job',
+                    timestamp: entry.timestamp,
+                    ...(entry.sessionId ? { sessionId: entry.sessionId } : {}),
+                    bootstrap: readRecord(validationSummary?.bootstrap),
+                    validation: validationSummary
+                        ? Object.fromEntries(Object.entries(validationSummary).filter(([key]) => key !== 'bootstrap'))
+                        : null,
+                    checkpoint: readRecord(result?.checkpoint),
+                    worker: null,
+                    ...(readRecord(payload.finalBranchConvergenceState) ?? readRecord(result?.finalBranchConvergenceState)
+                        ? { finalBranchConvergenceState: (readRecord(payload.finalBranchConvergenceState) ?? readRecord(result?.finalBranchConvergenceState))! }
+                        : {}),
+                    ...(readRecord(payload.refineJob) ? { refineJob: readRecord(payload.refineJob)! } : {}),
+                };
+            } else {
+                const envelope = readRecord(payload.evidence);
+                evidence = {
+                    available: true,
+                    kind: entry.kind,
+                    source: 'task_completion',
+                    timestamp: entry.timestamp,
+                    ...(readString(payload.taskId) ? { taskId: readString(payload.taskId)! } : {}),
+                    ...(entry.sessionId ? { sessionId: entry.sessionId } : {}),
+                    bootstrap: null,
+                    validation: readRecord(envelope?.validation),
+                    checkpoint: readRecord(envelope?.checkpoint),
+                    worker: readWorkerArtifact(envelope?.workerResult ?? payload.workerResult),
+                };
+            }
+        }
+
+        if (!transcriptHandle) {
+            const envelope = readRecord(payload.evidence);
+            transcriptHandle = readRecord(envelope?.transcriptHandle);
+        }
+
+        if (evidence.available && transcriptHandle) break;
+    }
+
+    return { evidence, transcriptHandle };
+}
+
+/** Latest refine terminal result for a node that classified it blocked_review. */
+function hasBlockedReviewRefineResult(nodeId: string, ledgerEntries: MeshLedgerEntry[]): boolean {
+    for (let i = ledgerEntries.length - 1; i >= 0; i--) {
+        const entry = ledgerEntries[i];
+        if (entry.nodeId !== nodeId || !isTerminalLedgerKind(entry.kind)) continue;
+        const payload = readRecord(entry.payload) ?? {};
+        if (payload.source !== 'refine_mesh_node_async_job') continue;
+        const result = readRecord(payload.result);
+        const finalState = readRecord(payload.finalBranchConvergenceState) ?? readRecord(result?.finalBranchConvergenceState);
+        // Only the most recent refine terminal counts — an older blocked_review
+        // superseded by a successful refine must not resurrect the card.
+        return readString(finalState?.status) === 'blocked_review'
+            || readString(result?.code) === 'blocked_review';
+    }
+    return false;
+}
+
+/**
+ * Derive review inbox items from mesh_status node statuses and a bounded
+ * ledger tail. Pure and read-only; the caller attaches diffSummary separately.
+ */
+export function deriveMeshReviewInboxItems(args: {
+    nodes: Array<Record<string, unknown>>;
+    ledgerEntries: MeshLedgerEntry[];
+}): MeshReviewInboxDerivation {
+    const items: MeshReviewInboxItem[] = [];
+    const excludedRemoteNodeIds: string[] = [];
+    const refineJobs = buildMeshAsyncRefineJobs({ ledgerEntries: args.ledgerEntries });
+
+    for (const node of args.nodes) {
+        const nodeId = readString(node.nodeId) ?? readString(node.id);
+        if (!nodeId) continue;
+
+        if (!isLocalNodeStatus(node)) {
+            excludedRemoteNodeIds.push(nodeId);
+            continue;
+        }
+
+        const convergence = readNodeConvergence(node);
+        if (!convergence) continue;
+        if (convergence.status === 'merged_to_main') continue;
+
+        let reviewReason: MeshReviewInboxReason | null = null;
+        if (hasBlockedReviewRefineResult(nodeId, args.ledgerEntries)) {
+            reviewReason = 'refine_blocked_review';
+        } else if (isMergeCandidate(convergence)) {
+            reviewReason = 'merge_candidate';
+        }
+        if (!reviewReason) continue;
+
+        const { evidence, transcriptHandle } = resolveNodeEvidence(nodeId, args.ledgerEntries);
+        const activeRefineJob = [...refineJobs].reverse().find(job =>
+            (job.nodeId === nodeId || job.targetNodeId === nodeId)
+            && (job.status === 'accepted' || job.status === 'running'),
+        ) ?? null;
+
+        items.push({
+            nodeId,
+            workspace: readString(node.workspace),
+            branch: convergence.branch ?? readString(node.worktreeBranch),
+            defaultBranch: convergence.defaultBranch,
+            isLocalWorktree: node.isLocalWorktree === true,
+            reviewReason,
+            convergence: {
+                status: convergence.status,
+                reason: convergence.reason,
+                nextStep: convergence.nextStep,
+                needsConvergence: convergence.needsConvergence,
+            },
+            evidence,
+            transcriptHandle,
+            activeRefineJob: activeRefineJob as Record<string, unknown> | null,
+            lastActivityAt: evidence.timestamp ?? null,
+        });
+    }
+
+    return {
+        items,
+        remoteNodesExcluded: excludedRemoteNodeIds.length > 0,
+        excludedRemoteNodeIds,
+    };
+}