@adhdev/daemon-core 0.9.82-rc.43 → 0.9.82-rc.430

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

@@ -0,0 +1,231 @@
+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);
+    });
+}
+
+const TERMINAL_REFINE_STATUSES = new Set<MeshAsyncRefineJobStatus>(['completed', 'failed']);
+
+/** Terminal refine jobs older than this (relative to the newest job in the set) are
+ * "stale" — already-resolved historical refinery rejections/successes that should not
+ * keep inflating the status counts in mesh_status. 6h covers a long working session
+ * while still folding multi-day-old residue. */
+export const STALE_TERMINAL_REFINE_WINDOW_MS = 6 * 60 * 60 * 1000;
+
+/** Cap on how many recent terminal jobs are counted even if all fall inside the freshness
+ * window — prevents a burst of refines from dominating the summary. */
+export const RECENT_TERMINAL_REFINE_CAP = 8;
+
+export interface MeshAsyncRefineJobsSummary {
+    /** Count of jobs reflected in `byStatus` (active jobs + recent terminal jobs). */
+    total: number;
+    byStatus: Record<string, number>;
+    /** Terminal jobs dropped from the counts because they are stale residue. */
+    staleTerminal: number;
+    /** Non-terminal (accepted/running) jobs still in flight. */
+    activeJobs: MeshAsyncRefineJobSummary[];
+}
+
+function jobActivityTime(job: MeshAsyncRefineJobSummary): number {
+    const raw = job.lastUpdatedAt || job.completedAt || job.startedAt || '';
+    const t = new Date(raw).getTime();
+    return Number.isFinite(t) ? t : 0;
+}
+
+/**
+ * Build a compact summary of refine jobs that folds stale terminal jobs.
+ *
+ * The full job list (from `buildMeshAsyncRefineJobs`) is derived from a recent ledger
+ * window and deduped by jobId, but it still includes every terminal (completed/failed)
+ * job that happens to fall in that window — including multi-day-old refinery rejections
+ * that have long since been resolved. Those stale terminals inflate `byStatus.failed`
+ * and read as "current breakage" when they are historical noise.
+ *
+ * Active (accepted/running) jobs are always counted. Terminal jobs are counted only when
+ * they are recent: within `STALE_TERMINAL_REFINE_WINDOW_MS` of the newest job's activity
+ * time AND among the `RECENT_TERMINAL_REFINE_CAP` most-recent terminals. Everything else
+ * is folded into `staleTerminal` and excluded from `byStatus`.
+ *
+ * Freshness is measured relative to the newest job in the set (not wall-clock), so the
+ * result is deterministic for a given input — important for tests and for stale-clock
+ * environments.
+ */
+export function summarizeMeshAsyncRefineJobs(
+    jobs: MeshAsyncRefineJobSummary[],
+): MeshAsyncRefineJobsSummary {
+    const activeJobs: MeshAsyncRefineJobSummary[] = [];
+    const terminalJobs: MeshAsyncRefineJobSummary[] = [];
+    for (const job of jobs) {
+        if (TERMINAL_REFINE_STATUSES.has(job.status)) terminalJobs.push(job);
+        else activeJobs.push(job);
+    }
+
+    // Newest activity across ALL jobs anchors the freshness window.
+    let newest = 0;
+    for (const job of jobs) newest = Math.max(newest, jobActivityTime(job));
+    const cutoff = newest - STALE_TERMINAL_REFINE_WINDOW_MS;
+
+    const terminalByRecency = [...terminalJobs].sort(
+        (a, b) => jobActivityTime(b) - jobActivityTime(a),
+    );
+    const freshTerminal = terminalByRecency
+        .filter(job => jobActivityTime(job) >= cutoff)
+        .slice(0, RECENT_TERMINAL_REFINE_CAP);
+    const freshTerminalIds = new Set(freshTerminal.map(job => job.jobId));
+
+    const byStatus: Record<string, number> = {};
+    for (const job of activeJobs) {
+        byStatus[job.status] = (byStatus[job.status] ?? 0) + 1;
+    }
+    for (const job of freshTerminal) {
+        byStatus[job.status] = (byStatus[job.status] ?? 0) + 1;
+    }
+
+    const staleTerminal = terminalJobs.length - freshTerminalIds.size;
+
+    return {
+        total: activeJobs.length + freshTerminal.length,
+        byStatus,
+        staleTerminal,
+        activeJobs,
+    };
+}

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,
+    };
+}