@adhdev/daemon-core 0.9.82-rc.326 → 0.9.82-rc.328

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

@@ -101,6 +101,72 @@ export type StaleDirectPruneClassification = 'prunable_orphan' | 'prunable_termi
 export declare function classifyStaleDirectForPrune(record: Pick<MeshActiveWorkRecord, 'staleReason' | 'staleDispatchUnacknowledged' | 'terminal'>, opts?: {
     includeTerminal?: boolean;
 }): StaleDirectPruneClassification;
+/**
+ * Outcome of one staleDirect prune pass. Pure data — callers (the MCP tool, the
+ * daemon reconcile loop) format/log this however they need. The MCP tool wraps it in
+ * its JSON response; the reconcile loop logs prunedCount when > 0.
+ */
+export interface StaleDirectPruneResult {
+    mode: 'execute' | 'dry_run';
+    includeTerminal: boolean;
+    /** Total staleDirect (+terminal when included) candidates surfaced this pass. */
+    candidateCount: number;
+    /** Records classified prunable AND (when minAgeMs > 0) old enough to auto-prune. */
+    prunable: MeshActiveWorkRecord[];
+    prunedCount: number;
+    /** Prunable by classification but younger than the age gate — only populated when minAgeMs > 0. */
+    skippedTooYoung: MeshActiveWorkRecord[];
+    preservedUnacknowledged: MeshActiveWorkRecord[];
+    /** Prunable orphans/terminals with no store-backed row to delete (ledger-only audit). */
+    preservedLedgerOnly: MeshActiveWorkRecord[];
+    preservedNotOrphan: MeshActiveWorkRecord[];
+}
+export interface PruneStaleDirectDispatchesOptions {
+    meshId: string;
+    /** Active direct dispatches from MeshRuntimeStore (getActiveDirectDispatches). */
+    directDispatches: DirectDispatchRecord[];
+    /** Ledger tail used to attribute remote/terminal dispatches (readLedgerEntries). */
+    ledgerEntries?: MeshLedgerEntry[];
+    queue?: MeshWorkQueueEntry[];
+    /** Live mesh nodes (decorated with live session details) — drives orphan detection. */
+    nodes?: any[];
+    /** When true, actually delete + append the audit ledger entry. Default false (dry run). */
+    execute?: boolean;
+    /** Include terminal (idle/failed) direct rows as prune candidates. Default false. */
+    includeTerminal?: boolean;
+    /**
+     * Minimum age (ms, measured from createdAt/dispatchedAt) before a prunable orphan is
+     * eligible. 0 (default) prunes immediately regardless of age — the manual prune behavior.
+     * The daemon auto-prune passes a conservative threshold so a node/session that is only
+     * transiently invisible is never pruned on the spot.
+     */
+    minAgeMs?: number;
+    /** Audit source string written into the direct_dispatch_pruned ledger payload. */
+    source?: string;
+    now?: number;
+}
+/**
+ * Shared staleDirect prune core. Single source of truth for the prune decision + the
+ * mutation (store-row delete + audit-ledger append) used by BOTH the manual MCP tool
+ * (mesh_prune_stale_direct, minAgeMs=0) and the daemon reconcile loop's auto-prune
+ * PHASE (minAgeMs > 0). Pure decision logic via buildMeshActiveWork + classifyStaleDirectForPrune;
+ * the only side effects (on execute) are deleteDirectDispatchesByTaskId and a single
+ * direct_dispatch_pruned ledger entry — never touching the append-only audit history of the
+ * pruned dispatches themselves.
+ *
+ * Safety rules (identical for manual + auto):
+ *  - Only records classified as staleDirectWork against the CURRENT live mesh are eligible.
+ *  - Of those, only orphans (node/session gone) — and terminals when includeTerminal — are prunable.
+ *    Fresh unacknowledged dispatch failures (node/session still live) are always preserved.
+ *  - Only store-backed rows (taskId present in MeshRuntimeStore) are deleted; ledger-only remote
+ *    entries are preserved.
+ *  - When minAgeMs > 0, a prunable orphan younger than the gate is held back (skippedTooYoung).
+ *    This applies ONLY to the auto path; the manual path passes minAgeMs=0 (immediate).
+ *
+ * Idempotent: a deleted row no longer appears in getActiveDirectDispatches, so a second pass
+ * over the same orphan finds nothing to prune.
+ */
+export declare function pruneStaleDirectDispatches(opts: PruneStaleDirectDispatchesOptions): StaleDirectPruneResult;
 export declare function buildCompactStaleDirectWorkSummary(staleDirectWork: MeshActiveWorkRecord[], opts?: {
     sampleLimit?: number;
     detailHint?: string;

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

@@ -84,6 +84,8 @@ export declare function buildMeshNodeCapabilityTags(node: {
     isLocalWorktree?: unknown;
     worktreeBranch?: unknown;
     userOverrides?: unknown;
+    reportedPlatform?: unknown;
+    reportedArch?: unknown;
 } | undefined, providerType?: string): string[];
 export declare function nodeSatisfiesRequiredTags(requiredTags: unknown, capabilityTags: unknown): boolean;
 /**

package/dist/repo-mesh-types.d.ts

@@ -418,6 +418,18 @@ export interface LocalMeshNodeEntry {
     /** Operator-defined capability tags used by mesh queue matching. */
     capabilities?: string[];
     userOverrides: Partial<RepoMeshNodeCapabilities>;
+    /**
+     * Live, self-healed platform/arch reported by the daemon that owns this
+     * node's workspace (its own process.platform/process.arch), carried on the
+     * git_status envelope and persisted by the coordinator on each direct git
+     * probe. This is auto-detected truth, kept DISTINCT from `userOverrides`
+     * (operator intent) so capability-tag derivation can prefer an explicit
+     * operator override while still self-correcting auto-detected nodes — and so
+     * a stale value is overwritten by the next report rather than sticking.
+     * Absent until the first direct probe succeeds.
+     */
+    reportedPlatform?: string;
+    reportedArch?: string;
     policy: RepoMeshNodePolicy;
     /**
      * Per-node instruction surfaced in the coordinator prompt so the LLM

package/package.json

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

package/src/commands/router.ts

@@ -407,8 +407,10 @@ function recordInlineMeshDirectGitTruth(
     node: any,
     git: Record<string, unknown>,
     source: 'selected_coordinator_local_git' | 'selected_coordinator_mesh_p2p_git',
-): void {
-    if (!node || typeof node !== 'object' || Array.isArray(node)) return;
+): { reporterPlatform: string | null; reporterArch: string | null } {
+    if (!node || typeof node !== 'object' || Array.isArray(node)) {
+        return { reporterPlatform: null, reporterArch: null };
+    }
     const checkedAt = readNumberValue(git.lastCheckedAt) ?? Date.now();
     const updatedAt = new Date(checkedAt).toISOString();
     const nextGit: Record<string, unknown> = {
@@ -439,6 +441,13 @@ function recordInlineMeshDirectGitTruth(
     const reporterPlatform = readStringValue(git.reporterPlatform) ?? (isLocalSource ? process.platform : null);
     const reporterArch = readStringValue(git.reporterArch) ?? (isLocalSource ? process.arch : null);
     stampNodeReporterPlatform(node, reporterPlatform, reporterArch);
+    // Mirror onto the in-memory node's dedicated reporter fields too (distinct
+    // from userOverrides). For a local_config mesh the caller also persists these
+    // to meshes.json via updateNode so the value survives a coordinator restart;
+    // for an inline/cache mesh this keeps the runtime object self-consistent.
+    if (reporterPlatform) node.reportedPlatform = reporterPlatform;
+    if (reporterArch) node.reportedArch = reporterArch;
+    return { reporterPlatform, reporterArch };
 }
 
 /**
@@ -460,6 +469,34 @@ function stampNodeReporterPlatform(node: any, platform: string | null, arch: str
     if (changed) node.userOverrides = overrides;
 }
 
+/**
+ * Persist the live self-reported platform/arch onto the local meshes.json node
+ * record so capability-tag os=/arch= self-heals across coordinator restarts.
+ *
+ * The in-memory stamp done by recordInlineMeshDirectGitTruth lives on the
+ * mesh_status assembly object and is discarded after the response; only a
+ * `local_config` mesh has a backing meshes.json node to write through to. Inline
+ * cache/bootstrap meshes have no local node to update, so we no-op for them.
+ * Fire-and-forget (same pattern as the worktreeBootstrap writer) — a persistence
+ * failure must never block the status response.
+ */
+function persistNodeReporterPlatform(
+    meshSource: 'inline_cache' | 'inline_bootstrap' | 'local_config',
+    mesh: any,
+    nodeId: string | undefined,
+    reporter: { reporterPlatform: string | null; reporterArch: string | null },
+): void {
+    if (meshSource !== 'local_config') return;
+    const meshId = readStringValue(mesh?.id);
+    if (!meshId || !nodeId) return;
+    const reportedPlatform = reporter.reporterPlatform ?? undefined;
+    const reportedArch = reporter.reporterArch ?? undefined;
+    if (!reportedPlatform && !reportedArch) return;
+    void import('../config/mesh-config.js')
+        .then(({ updateNode }) => updateNode(meshId, nodeId, { reportedPlatform, reportedArch }))
+        .catch(() => { /* best-effort self-heal; never block status assembly */ });
+}
+
 function buildCachedInlineMeshGitStatus(node: any): Record<string, unknown> | undefined {
     const liveGit = buildInlineMeshTransitGitStatus(node);
     if (liveGit) return liveGit;
@@ -1323,7 +1360,8 @@ async function hydrateInlineMeshDirectTruth(args: {
             try {
                 const localGit = await getGitRepoStatus(workspace, { timeoutMs: 10_000, refreshUpstream: true });
                 if (localGit?.isGitRepo) {
-                    recordInlineMeshDirectGitTruth(node, localGit as unknown as Record<string, unknown>, 'selected_coordinator_local_git');
+                    const reporter = recordInlineMeshDirectGitTruth(node, localGit as unknown as Record<string, unknown>, 'selected_coordinator_local_git');
+                    persistNodeReporterPlatform(args.meshSource, args.mesh, nodeId, reporter);
                     localConfirmedCount += 1;
                     continue;
                 }
@@ -1375,7 +1413,8 @@ async function hydrateInlineMeshDirectTruth(args: {
             ? await args.probeCache.probe(daemonId, workspace, runProbe)
             : await runProbe();
         if (remoteGit) {
-            recordInlineMeshDirectGitTruth(node, remoteGit, 'selected_coordinator_mesh_p2p_git');
+            const reporter = recordInlineMeshDirectGitTruth(node, remoteGit, 'selected_coordinator_mesh_p2p_git');
+            persistNodeReporterPlatform(args.meshSource, args.mesh, nodeId, reporter);
             peerConfirmedCount += 1;
             continue;
         }
@@ -9299,7 +9338,8 @@ export class DaemonCommandRouter {
                                         if (!connectionReported || connectionState === 'unknown') {
                                             status.connection = buildLivePeerGitConnection(connection, refreshedAt);
                                         }
-                                        recordInlineMeshDirectGitTruth(node, remoteGit, 'selected_coordinator_mesh_p2p_git');
+                                        const reporter = recordInlineMeshDirectGitTruth(node, remoteGit, 'selected_coordinator_mesh_p2p_git');
+                                        persistNodeReporterPlatform(meshRecord.source, mesh, nodeId, reporter);
                                         remoteProbeApplied = true;
                                     }
                                 }
@@ -9340,7 +9380,8 @@ export class DaemonCommandRouter {
                                 try {
                                     const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 10_000, refreshUpstream: true });
                                     status.git = gitStatus;
-                                    recordInlineMeshDirectGitTruth(node, gitStatus as unknown as Record<string, unknown>, 'selected_coordinator_local_git');
+                                    const reporter = recordInlineMeshDirectGitTruth(node, gitStatus as unknown as Record<string, unknown>, 'selected_coordinator_local_git');
+                                    persistNodeReporterPlatform(meshRecord.source, mesh, nodeId, reporter);
                                     if (gitStatus.isGitRepo) {
                                         status.health = deriveMeshNodeHealthFromGit(gitStatus as unknown as Record<string, unknown>);
                                     } else {

package/src/config/mesh-config.ts

@@ -604,6 +604,11 @@ export function updateNode(
         /** Per-node instruction surfaced in the coordinator prompt. Pass an
          *  empty string or undefined to clear it. */
         systemPrompt?: string;
+        /** Live self-reported platform/arch from the owning daemon's git_status
+         *  envelope. Persisted distinctly from userOverrides (auto-detected, not
+         *  operator intent) so capability-tag os=/arch= self-heals across loads. */
+        reportedPlatform?: string;
+        reportedArch?: string;
     },
 ): LocalMeshNodeEntry | undefined {
     const config = loadMeshConfig();
@@ -614,6 +619,8 @@ export function updateNode(
     if (!node) return undefined;
 
     if (opts.userOverrides) node.userOverrides = { ...node.userOverrides, ...opts.userOverrides };
+    if (opts.reportedPlatform && opts.reportedPlatform.trim()) node.reportedPlatform = opts.reportedPlatform.trim();
+    if (opts.reportedArch && opts.reportedArch.trim()) node.reportedArch = opts.reportedArch.trim();
     if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
     if (opts.worktreeBootstrap) node.worktreeBootstrap = opts.worktreeBootstrap;
     if (Object.prototype.hasOwnProperty.call(opts, 'systemPrompt')) {

package/src/index.ts

@@ -233,8 +233,8 @@ export type { AnyLedgerSlice, MeshLedgerReconciliationEvidence, MeshLedgerReplic
 // ── Mesh Work Queue (GUPP) ──
 export { enqueueTask, recordDirectDispatchTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats, getMeshQueueRevision, normalizeMeshTaskMode, validateMeshTaskModeRequest, buildMeshNodeCapabilityTags, nodeSatisfiesRequiredTags, normalizeMeshCapabilityTags, resolveConvergeRequiredTags, insertDirectDispatch, getActiveDirectDispatches, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, markStaleDirectDispatches, deleteDirectDispatchesByTaskId, recordMeshToolCall, assertNoDependencyCycle, hasPendingDependents, describeTaskDependencyState } from './mesh/mesh-work-queue.js';
 export type { MeshWorkQueueEntry, MeshTaskStatus, MeshTaskMode, MeshWorkQueueStats, MeshQueueMutationOptions, MeshTaskModeValidationResult, DirectDispatchRecord, MeshToolCallRateResult } from './mesh/mesh-work-queue.js';
-export { buildCompactStaleDirectWorkSummary, buildMeshActiveWork, buildMeshActiveWorkSummary, classifyStaleDirectForPrune, PRUNABLE_ORPHAN_STALE_REASONS } from './mesh/mesh-active-work.js';
-export type { StaleDirectPruneClassification } from './mesh/mesh-active-work.js';
+export { buildCompactStaleDirectWorkSummary, buildMeshActiveWork, buildMeshActiveWorkSummary, classifyStaleDirectForPrune, pruneStaleDirectDispatches, PRUNABLE_ORPHAN_STALE_REASONS } from './mesh/mesh-active-work.js';
+export type { StaleDirectPruneClassification, StaleDirectPruneResult, PruneStaleDirectDispatchesOptions } from './mesh/mesh-active-work.js';
 export type { MeshActiveWorkRecord, MeshActiveWorkStatus, MeshActiveWorkSummary, MeshActiveWorkSource, MeshStaleDirectWorkSummary } from './mesh/mesh-active-work.js';
 export { buildMeshAsyncRefineJobs, summarizeMeshAsyncRefineJobs, STALE_TERMINAL_REFINE_WINDOW_MS, RECENT_TERMINAL_REFINE_CAP } from './mesh/mesh-refine-status.js';
 export type { MeshAsyncRefineJobStatus, MeshAsyncRefineJobSummary, MeshAsyncRefineJobsSummary } from './mesh/mesh-refine-status.js';

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

@@ -1,5 +1,7 @@
 import type { MeshLedgerEntry } from './mesh-ledger.js';
+import { appendLedgerEntry } from './mesh-ledger.js';
 import type { MeshWorkQueueEntry, DirectDispatchRecord } from './mesh-work-queue.js';
+import { deleteDirectDispatchesByTaskId } from './mesh-work-queue.js';
 import { meshNodeIdMatches } from '@adhdev/mesh-shared';
 
 export type MeshActiveWorkSource = 'queue' | 'direct';
@@ -440,6 +442,158 @@ export function classifyStaleDirectForPrune(
     return 'preserve_active';
 }
 
+/**
+ * Outcome of one staleDirect prune pass. Pure data — callers (the MCP tool, the
+ * daemon reconcile loop) format/log this however they need. The MCP tool wraps it in
+ * its JSON response; the reconcile loop logs prunedCount when > 0.
+ */
+export interface StaleDirectPruneResult {
+    mode: 'execute' | 'dry_run';
+    includeTerminal: boolean;
+    /** Total staleDirect (+terminal when included) candidates surfaced this pass. */
+    candidateCount: number;
+    /** Records classified prunable AND (when minAgeMs > 0) old enough to auto-prune. */
+    prunable: MeshActiveWorkRecord[];
+    prunedCount: number;
+    /** Prunable by classification but younger than the age gate — only populated when minAgeMs > 0. */
+    skippedTooYoung: MeshActiveWorkRecord[];
+    preservedUnacknowledged: MeshActiveWorkRecord[];
+    /** Prunable orphans/terminals with no store-backed row to delete (ledger-only audit). */
+    preservedLedgerOnly: MeshActiveWorkRecord[];
+    preservedNotOrphan: MeshActiveWorkRecord[];
+}
+
+export interface PruneStaleDirectDispatchesOptions {
+    meshId: string;
+    /** Active direct dispatches from MeshRuntimeStore (getActiveDirectDispatches). */
+    directDispatches: DirectDispatchRecord[];
+    /** Ledger tail used to attribute remote/terminal dispatches (readLedgerEntries). */
+    ledgerEntries?: MeshLedgerEntry[];
+    queue?: MeshWorkQueueEntry[];
+    /** Live mesh nodes (decorated with live session details) — drives orphan detection. */
+    nodes?: any[];
+    /** When true, actually delete + append the audit ledger entry. Default false (dry run). */
+    execute?: boolean;
+    /** Include terminal (idle/failed) direct rows as prune candidates. Default false. */
+    includeTerminal?: boolean;
+    /**
+     * Minimum age (ms, measured from createdAt/dispatchedAt) before a prunable orphan is
+     * eligible. 0 (default) prunes immediately regardless of age — the manual prune behavior.
+     * The daemon auto-prune passes a conservative threshold so a node/session that is only
+     * transiently invisible is never pruned on the spot.
+     */
+    minAgeMs?: number;
+    /** Audit source string written into the direct_dispatch_pruned ledger payload. */
+    source?: string;
+    now?: number;
+}
+
+/**
+ * Shared staleDirect prune core. Single source of truth for the prune decision + the
+ * mutation (store-row delete + audit-ledger append) used by BOTH the manual MCP tool
+ * (mesh_prune_stale_direct, minAgeMs=0) and the daemon reconcile loop's auto-prune
+ * PHASE (minAgeMs > 0). Pure decision logic via buildMeshActiveWork + classifyStaleDirectForPrune;
+ * the only side effects (on execute) are deleteDirectDispatchesByTaskId and a single
+ * direct_dispatch_pruned ledger entry — never touching the append-only audit history of the
+ * pruned dispatches themselves.
+ *
+ * Safety rules (identical for manual + auto):
+ *  - Only records classified as staleDirectWork against the CURRENT live mesh are eligible.
+ *  - Of those, only orphans (node/session gone) — and terminals when includeTerminal — are prunable.
+ *    Fresh unacknowledged dispatch failures (node/session still live) are always preserved.
+ *  - Only store-backed rows (taskId present in MeshRuntimeStore) are deleted; ledger-only remote
+ *    entries are preserved.
+ *  - When minAgeMs > 0, a prunable orphan younger than the gate is held back (skippedTooYoung).
+ *    This applies ONLY to the auto path; the manual path passes minAgeMs=0 (immediate).
+ *
+ * Idempotent: a deleted row no longer appears in getActiveDirectDispatches, so a second pass
+ * over the same orphan finds nothing to prune.
+ */
+export function pruneStaleDirectDispatches(opts: PruneStaleDirectDispatchesOptions): StaleDirectPruneResult {
+    const now = opts.now ?? Date.now();
+    const includeTerminal = opts.includeTerminal === true;
+    const execute = opts.execute === true;
+    const minAgeMs = Math.max(0, opts.minAgeMs ?? 0);
+
+    const activeWorkEvidence = buildMeshActiveWork({
+        meshId: opts.meshId,
+        queue: opts.queue,
+        ledgerEntries: opts.ledgerEntries,
+        directDispatches: opts.directDispatches,
+        nodes: opts.nodes,
+        now,
+        includeTerminalDirect: includeTerminal,
+    });
+
+    const candidates = [
+        ...activeWorkEvidence.staleDirectWork,
+        ...(includeTerminal ? activeWorkEvidence.terminalDirectWork : []),
+    ];
+    // Only prune store-backed dispatch rows (taskIds present in MeshRuntimeStore). Ledger-only
+    // remote entries have no store row to delete and are pure audit history — leave them alone.
+    const storeTaskIds = new Set(opts.directDispatches.map(d => d.taskId));
+
+    const prunable: MeshActiveWorkRecord[] = [];
+    const skippedTooYoung: MeshActiveWorkRecord[] = [];
+    const preservedUnacknowledged: MeshActiveWorkRecord[] = [];
+    const preservedLedgerOnly: MeshActiveWorkRecord[] = [];
+    const preservedNotOrphan: MeshActiveWorkRecord[] = [];
+    for (const record of candidates) {
+        const classification = classifyStaleDirectForPrune(record, { includeTerminal });
+        if (classification === 'preserve_unacknowledged') {
+            preservedUnacknowledged.push(record);
+            continue;
+        }
+        if (classification === 'preserve_active') {
+            preservedNotOrphan.push(record);
+            continue;
+        }
+        // prunable_orphan | prunable_terminal — only delete store-backed rows; ledger-only remote
+        // entries have no store row to delete and are pure audit history.
+        if (!storeTaskIds.has(record.taskId)) {
+            preservedLedgerOnly.push(record);
+            continue;
+        }
+        // Age gate (auto path only): hold back orphans that are too fresh — a node/session that is
+        // only transiently invisible must not be pruned the instant it disappears.
+        if (minAgeMs > 0) {
+            const ageRef = record.dispatchedAt || record.createdAt;
+            const ageMs = elapsedSince(ageRef, now);
+            if (ageMs < minAgeMs) {
+                skippedTooYoung.push(record);
+                continue;
+            }
+        }
+        prunable.push(record);
+    }
+
+    let prunedCount = 0;
+    if (execute && prunable.length) {
+        prunedCount = deleteDirectDispatchesByTaskId(opts.meshId, prunable.map(r => r.taskId));
+        appendLedgerEntry(opts.meshId, {
+            kind: 'direct_dispatch_pruned',
+            payload: {
+                source: opts.source || 'prune_stale_direct',
+                prunedCount,
+                taskIds: prunable.map(r => r.taskId),
+                reasons: Array.from(new Set(prunable.map(r => r.staleReason || (r.terminal ? 'terminal' : 'unknown')))),
+            },
+        });
+    }
+
+    return {
+        mode: execute ? 'execute' : 'dry_run',
+        includeTerminal,
+        candidateCount: candidates.length,
+        prunable,
+        prunedCount,
+        skippedTooYoung,
+        preservedUnacknowledged,
+        preservedLedgerOnly,
+        preservedNotOrphan,
+    };
+}
+
 export function buildCompactStaleDirectWorkSummary(
     staleDirectWork: MeshActiveWorkRecord[],
     opts: { sampleLimit?: number; detailHint?: string; note?: string } = {},

package/src/mesh/mesh-reconcile-loop.ts

@@ -55,7 +55,9 @@ import {
     expireStaleUnresolvedDelegateForwards,
 } from './mesh-unresolved-forward-outbox.js';
 import { readNonEmptyString } from './mesh-events-utils.js';
-import { getActiveDirectDispatches } from './mesh-work-queue.js';
+import { getActiveDirectDispatches, getQueue } from './mesh-work-queue.js';
+import { readLedgerEntries } from './mesh-ledger.js';
+import { pruneStaleDirectDispatches } from './mesh-active-work.js';
 import { reconcileDirectDispatchCompletionFromTranscript } from './mesh-events-stale.js';
 import { extractFinalAssistantSummaryEvidence } from '../providers/chat-message-normalization.js';
 import type { ChatMessage } from '../types.js';
@@ -64,6 +66,25 @@ import type { ChatMessage } from '../types.js';
 // coordinator land within at most one interval. Overridable via env for tuning.
 const DEFAULT_RECONCILE_INTERVAL_MS = 4_000;
 
+// PHASE 5 (auto-prune) conservative age gate. A direct dispatch whose node/session is
+// orphaned (no longer in the live mesh) is only auto-pruned once it is at least this old,
+// measured from its dispatch time. This protects against a node/session that is only
+// *transiently* invisible (a momentary probe failure, a daemon restart) being pruned the
+// instant it disappears. The MANUAL prune (mesh_prune_stale_direct) has no age gate — an
+// operator pruning explicitly wants the orphan gone now. Overridable via env for tuning.
+const DEFAULT_AUTO_PRUNE_MIN_AGE_MS = 24 * 60 * 60_000; // 24h
+
+function resolveAutoPruneMinAgeMs(): number {
+    const raw = readNonEmptyString(process.env.MESH_AUTO_PRUNE_MIN_AGE_MS);
+    if (raw) {
+        const parsed = Number.parseInt(raw, 10);
+        // Clamp to [1h, 30d] so a mis-set env can't make the gate pathologically aggressive
+        // (prune the moment something blinks) or effectively disable it forever.
+        if (Number.isFinite(parsed) && parsed >= 60 * 60_000 && parsed <= 30 * 24 * 60 * 60_000) return parsed;
+    }
+    return DEFAULT_AUTO_PRUNE_MIN_AGE_MS;
+}
+
 function resolveReconcileIntervalMs(): number {
     const raw = readNonEmptyString(process.env.MESH_RECONCILE_INTERVAL_MS);
     if (raw) {
@@ -310,6 +331,36 @@ export async function runMeshReconcileTick(components: DaemonComponents): Promis
         }
     }
 
+    // ── PHASE 5: auto-prune orphaned direct dispatch records ───────────────────
+    // staleDirectWork (orphaned direct-dispatch rows whose node/session is no longer in the
+    // live mesh) otherwise accumulates indefinitely: a removed worktree node or a cleanly
+    // terminated session leaves its direct-dispatch row behind, stuck in a non-terminal status
+    // (e.g. generating) for days. This is NOT a false-idle bug — it is the separate problem of
+    // orphaned records that the only existing cleanup path (manual MCP mesh_prune_stale_direct)
+    // never reaches unless an operator runs it by hand.
+    //
+    // This phase runs the SAME prune core the manual tool calls (pruneStaleDirectDispatches),
+    // in execute mode, on the daemon timer. The only difference from the manual path is a
+    // conservative age gate (DEFAULT_AUTO_PRUNE_MIN_AGE_MS): a freshly-orphaned record is held
+    // back until it is provably stale, so a transient probe miss never auto-prunes live work.
+    // Every other safety rule is inherited unchanged from the core — active/pending/generating
+    // work and fresh unacknowledged dispatch failures are never pruned, ledger-only audit entries
+    // are preserved, and the prune itself is recorded with a direct_dispatch_pruned ledger entry.
+    // Idempotent: a pruned row is gone from getActiveDirectDispatches, so the next tick finds
+    // nothing to re-prune. Isolated in its own try/catch per mesh so it can never kill the tick.
+    {
+        const minAgeMs = resolveAutoPruneMinAgeMs();
+        for (const mesh of listMeshes()) {
+            const selfIds = resolveCoordinatorSelfIds(mesh, drainDaemonIds);
+            if (!daemonHostsMesh(mesh, selfIds)) continue;
+            try {
+                await autoPruneStaleDirectDispatches(components, mesh, selfIds, localDaemonId, minAgeMs);
+            } catch (e: any) {
+                LOG.warn('MeshReconcile', `Auto-prune stale direct failed for mesh ${mesh.id}: ${e?.message || e}`);
+            }
+        }
+    }
+
     // ── PHASE 2: inject into live CLI coordinators on this daemon ──────────────
     const coordinators = findLiveCoordinators(components);
     if (coordinators.length === 0) {
@@ -592,6 +643,98 @@ async function reconcileUnterminatedDirectDispatches(
     }
 }
 
+// PHASE 5 helper. Build the live-node view (mesh.nodes decorated with each node's live
+// session list) and run the shared prune core in execute mode with the conservative age gate.
+//
+// Orphan detection needs the SAME live-session evidence the manual MCP prune uses: a node still
+// in mesh.nodes whose session list no longer contains the dispatched sessionId is "session not
+// present" (prunable); a node missing from mesh.nodes entirely is "node no longer in live mesh"
+// (prunable). We obtain live sessions per node via get_status_metadata — local nodes through the
+// local commandHandler, remote nodes over P2P (dispatchMeshCommand) — exactly the transports
+// PHASE 4 already uses. A node we cannot probe (offline) keeps an empty session list; combined
+// with the age gate that only matters once the orphan is genuinely old.
+//
+// O(1) fast exit: when there are no active direct dispatches at all there is nothing to prune,
+// so we skip the (per-node) status probes entirely — an idle mesh costs one indexed query.
+async function autoPruneStaleDirectDispatches(
+    components: DaemonComponents,
+    mesh: LocalMeshEntry,
+    selfIds: string[],
+    localDaemonId: string | undefined,
+    minAgeMs: number,
+): Promise<void> {
+    const directDispatches = getActiveDirectDispatches(mesh.id);
+    if (directDispatches.length === 0) return; // nothing dispatched → nothing to prune
+
+    const liveNodes = await collectLiveNodesWithSessions(components, mesh, selfIds, localDaemonId);
+
+    const result = pruneStaleDirectDispatches({
+        meshId: mesh.id,
+        queue: getQueue(mesh.id),
+        ledgerEntries: readLedgerEntries(mesh.id, { tail: 500 }),
+        directDispatches,
+        nodes: liveNodes,
+        execute: true,
+        minAgeMs,
+        source: 'daemon_reconcile_auto_prune',
+    });
+
+    // Log only when something was actually pruned — silence on the common no-op tick.
+    if (result.prunedCount > 0) {
+        LOG.info('MeshReconcile', `Auto-pruned ${result.prunedCount} orphaned direct dispatch record(s) for mesh ${mesh.id}`);
+    }
+}
+
+// Probe each node for its live session list (get_status_metadata) and return mesh.nodes
+// decorated with a `sessions` array — the shape buildMeshActiveWork / sessionStatusFromNodes
+// consume to decide whether a dispatched session is still present. Best-effort: an unreachable
+// node yields an empty session list rather than throwing.
+async function collectLiveNodesWithSessions(
+    components: DaemonComponents,
+    mesh: LocalMeshEntry,
+    selfIds: string[],
+    localDaemonId: string | undefined,
+): Promise<any[]> {
+    const dispatchMeshCommand = components.dispatchMeshCommand;
+    return Promise.all(mesh.nodes.map(async (node) => {
+        const nodeDaemonId = readNonEmptyString(node.daemonId);
+        const isLocalNode = !nodeDaemonId
+            || selfIds.includes(nodeDaemonId)
+            || (localDaemonId !== undefined && nodeDaemonId === localDaemonId);
+        let statusResult: unknown;
+        try {
+            if (isLocalNode) {
+                statusResult = await components.commandHandler.handle('get_status_metadata', {});
+            } else if (dispatchMeshCommand) {
+                statusResult = await dispatchMeshCommand(nodeDaemonId, 'get_status_metadata', {});
+            } else {
+                return node; // remote node, no P2P transport — leave undecorated
+            }
+        } catch {
+            return node; // unreachable — leave undecorated (empty session list)
+        }
+        const sessions = extractStatusMetadataSessions(statusResult);
+        return sessions.length > 0 ? { ...node, sessions } : node;
+    }));
+}
+
+// Pull the live session list out of a get_status_metadata result, tolerating the same
+// envelope shapes unwrapReadChatPayload handles (direct CommandResult or { payload }/{ result }).
+function extractStatusMetadataSessions(raw: unknown): any[] {
+    let cursor: unknown = raw;
+    for (let depth = 0; depth < 4 && cursor && typeof cursor === 'object'; depth++) {
+        const record = cursor as Record<string, unknown>;
+        const status = record.status && typeof record.status === 'object' ? record.status as Record<string, unknown> : undefined;
+        if (status && Array.isArray(status.sessions)) return status.sessions;
+        if (Array.isArray(record.sessions)) return record.sessions;
+        if (record.payload && typeof record.payload === 'object') { cursor = record.payload; continue; }
+        if (record.result && typeof record.result === 'object') { cursor = record.result; continue; }
+        if (record.data && typeof record.data === 'object') { cursor = record.data; continue; }
+        break;
+    }
+    return [];
+}
+
 function extractPendingEvents(raw: unknown): any[] {
     if (Array.isArray(raw)) return raw;
     if (raw && typeof raw === 'object') {

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

@@ -385,8 +385,20 @@ function readNodeOverride(node: { userOverrides?: unknown } | undefined, key: 'p
     return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
 
+/**
+ * Live, self-reported platform/arch the owning daemon stamped onto the node from
+ * its own process.platform/process.arch via the git_status envelope. Kept on a
+ * field DISTINCT from userOverrides so capability-tag derivation can prefer an
+ * explicit operator override while still self-healing auto-detected nodes — and
+ * so the value reflects the node's real OS rather than the coordinator's.
+ */
+function readNodeReporter(node: { reportedPlatform?: unknown; reportedArch?: unknown } | undefined, key: 'platform' | 'arch'): string | null {
+    const value = key === 'platform' ? node?.reportedPlatform : node?.reportedArch;
+    return typeof value === 'string' && value.trim() ? value.trim() : null;
+}
+
 export function buildMeshNodeCapabilityTags(
-    node: { capabilities?: unknown; policy?: unknown; isLocalWorktree?: unknown; worktreeBranch?: unknown; userOverrides?: unknown } | undefined,
+    node: { capabilities?: unknown; policy?: unknown; isLocalWorktree?: unknown; worktreeBranch?: unknown; userOverrides?: unknown; reportedPlatform?: unknown; reportedArch?: unknown } | undefined,
     providerType?: string,
 ): string[] {
     const provider = typeof providerType === 'string' && providerType.trim()
@@ -395,17 +407,25 @@ export function buildMeshNodeCapabilityTags(
     const worktreeBranch = typeof node?.worktreeBranch === 'string' && node.worktreeBranch.trim()
         ? node.worktreeBranch.trim()
         : null;
-    // Per-node platform/arch: prefer the value the remote daemon stamped into
-    // its node record (userOverrides.platform/arch) so a Windows member advertises
-    // os=win32 even though the COORDINATOR computing these tags runs on darwin.
-    // Fall back to process.platform/process.arch only when absent — that covers the
-    // local coordinator node and local worktree nodes, where process.* IS correct.
+    // Per-node platform/arch precedence (highest → lowest):
+    //   1. userOverrides.platform/arch — an EXPLICIT operator override always wins.
+    //   2. reportedPlatform/reportedArch — the live OS the owning daemon
+    //      self-reported (its own process.platform/process.arch via the git_status
+    //      envelope), persisted to the node record on each direct probe. This is
+    //      why a Windows member advertises os=win32 even though the COORDINATOR
+    //      computing these tags runs on darwin — without it the consumer reads the
+    //      persistent node (operator userOverrides empty) and would fall straight
+    //      through to the coordinator's own process.platform, mislabeling every
+    //      node os=darwin. We prefer this LIVE value over any stale auto-stamp.
+    //   3. process.platform/process.arch — last-resort fallback, correct only for
+    //      the local coordinator node / local worktree nodes that have not yet
+    //      been probed (their workspace lives on THIS machine anyway).
     // Vocabulary is raw process.platform/process.arch ("darwin"/"win32"/"linux",
     // "arm64"/"x64") on both the advertiser and the required_tags matcher, which
     // compares with plain string equality (nodeSatisfiesRequiredTags) — so this
     // keeps the win32/darwin/linux vocabulary the matcher already expects.
-    const os = readNodeOverride(node, 'platform') ?? process.platform;
-    const arch = readNodeOverride(node, 'arch') ?? process.arch;
+    const os = readNodeOverride(node, 'platform') ?? readNodeReporter(node, 'platform') ?? process.platform;
+    const arch = readNodeOverride(node, 'arch') ?? readNodeReporter(node, 'arch') ?? process.arch;
     return normalizeMeshCapabilityTags([
         ...(Array.isArray(node?.capabilities) ? node.capabilities : []),
         `os=${os}`,