@adhdev/daemon-core 0.9.82-rc.372 → 0.9.82-rc.374

package/dist/logging/log-tail-reader.d.ts

@@ -7,7 +7,21 @@
  * grep the file by hand. Because the mesh RPC envelope is sent as a single
  * datachannel message (~256KB SCTP ceiling, no chunking), the returned tail is
  * HARD-bounded by `tailBytes` (default 64KB, capped at MAX_TAIL_BYTES=128KB) and
- * flags `truncated:true` when the file was larger.
+ * flags `truncated:true` when more content existed than fit.
+ *
+ * Two read modes:
+ *  - No filter (no grep/sinceMs): byte-bounded tail of the active file — read the
+ *    last `tailBytes` bytes only. Cheap, backward-compatible.
+ *  - Filtered (grep and/or sinceMs given): FULL-FILE scan. The filter is applied
+ *    across the ENTIRE file (plus the size-rotation `.1.log` backup) BEFORE the
+ *    byte cap, then the last `tailBytes` worth of MATCHING lines are returned.
+ *    This is the fix for "matches hidden behind polling spam": when the recent
+ *    tail window is saturated with high-frequency lines (e.g. coordinator polling
+ *    `get_pending_mesh_events`/`read_chat` every few seconds), a grep for a rarer
+ *    earlier line (dispatch/inject/forward) previously matched 0 because the line
+ *    had already scrolled out of the tail window before the filter ran. Filtering
+ *    the whole file first surfaces those matches regardless of how much unrelated
+ *    spam followed them.
  *
  * Boundary-safe: lines are cut on the newline byte (0x0A) only, which never
  * appears inside a multibyte UTF-8 sequence, so decoding each complete byte
@@ -29,18 +43,39 @@ export interface DaemonLogTailResult {
     success: boolean;
     error?: string;
     lines: string[];
+    /**
+     * No-filter mode: true when the file was larger than the byte window.
+     * Filter mode: true when matching lines were dropped from the FRONT to fit
+     * the byte cap (i.e. there are older matches than the ones returned).
+     */
     truncated: boolean;
     logPath: string;
     platform: NodeJS.Platform;
     bytesReturned: number;
-    /** True when a grep/since filter dropped lines from the raw tail window. */
+    /** True when a grep/since filter dropped at least one line. */
     filtered: boolean;
     /** The grep source actually applied (echoed back for clarity). */
     grep?: string;
+    /** True when the filtered full-file scan path ran (grep/sinceMs given). */
+    fullScan: boolean;
+    /** Total bytes read while scanning (filter mode scans the whole file + backup). */
+    scannedBytes: number;
+    /** Number of lines that matched the filter across the full scan (filter mode). */
+    matchedLineCount: number;
+    /** Number of scanned lines dropped by the filter ("N lines excluded by filter"). */
+    excludedByFilter: number;
 }
 /**
- * Read the daemon log tail for `date` (default today), bounded to `tailBytes`,
- * with optional grep (regex source) and sinceMs filters. Falls back to the
- * size-rotation backup (`*.1.log`) when the primary file does not exist.
+ * Read the daemon log tail for `date` (default today), bounded to `tailBytes`.
+ *
+ * - No grep/sinceMs → byte-bounded tail of the active file (legacy behaviour).
+ * - grep and/or sinceMs given → FULL-FILE scan: the filter is applied across the
+ *   whole file (plus the `*.1.log` size-rotation backup) BEFORE the byte cap, so
+ *   matches that have scrolled out of the recent tail window (e.g. behind
+ *   coordinator polling spam) are still returned. Only the last `tailBytes` worth
+ *   of matching lines ship over P2P.
+ *
+ * Falls back to the size-rotation backup (`*.1.log`) when the primary file does
+ * not exist.
  */
 export declare function readDaemonLogTail(args?: ReadDaemonLogTailArgs): DaemonLogTailResult;

package/dist/mesh/mesh-events-stale.d.ts

@@ -11,6 +11,18 @@ export declare function findRecentTerminalLedgerEvidence(args: {
 } | null;
 export declare function hasDispatchAfterTerminal(meshId: string, sessionId: string, terminalId: string): boolean;
 export declare function hasUnterminalDirectDispatchLedgerEntry(meshId: string, sessionId: string): boolean;
+export declare function findTerminalLedgerEvidenceForTask(args: {
+    meshId: string;
+    taskId?: string;
+    sessionId?: string;
+    nodeId?: string;
+    tail?: number;
+}): {
+    id: string;
+    kind: Extract<MeshLedgerKind, 'task_completed' | 'task_failed' | 'task_stalled'>;
+    payload: Record<string, unknown>;
+    timestamp: string;
+} | null;
 export declare function reconcileDirectDispatchCompletionFromTranscript(args: {
     meshId: string;
     nodeId?: string;

package/dist/providers/chat-message-normalization.d.ts

@@ -1,5 +1,5 @@
 import type { ChatMessage } from '../types.js';
-export declare const DEFAULT_FINAL_SUMMARY_MAX_CHARS = 4000;
+export declare const DEFAULT_FINAL_SUMMARY_MAX_CHARS = 16000;
 export declare function extractFinalSummaryFromMessages(messages: ChatMessage[] | null | undefined, maxChars?: number): string;
 /**
  * Like extractFinalSummaryFromMessages but also returns the ISO timestamp of the

package/package.json

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

package/src/commands/low-family/mesh-node-logs.ts

@@ -75,6 +75,12 @@ export const meshNodeLogsHandlers: Record<string, LowFamilyHandler> = {
             truncated: tail.truncated,
             filtered: tail.filtered,
             bytesReturned: tail.bytesReturned,
+            // Transparency meta — lets the coordinator see that a full-file grep
+            // ran past the recent tail window, and how much was scanned/excluded.
+            fullScan: tail.fullScan,
+            scannedBytes: tail.scannedBytes,
+            matchedLineCount: tail.matchedLineCount,
+            excludedByFilter: tail.excludedByFilter,
             ...(tail.grep ? { grep: tail.grep } : {}),
         } as CommandRouterResult;
     },

package/src/commands/med-family/mesh-crud.ts

@@ -289,9 +289,19 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
                 const nodeMachineId = readMeshNodeMachineId(node as Record<string, unknown>) || '';
                 const selfDaemonId = ctx.deps.statusInstanceId || '';
                 const selfMachineId = (() => { try { return loadConfig().machineId || ''; } catch { return ''; } })();
+                // Identity match is form-safe: a daemon answers to the same machine
+                // under interchangeable id forms (bare `mach_X`, cloud `daemon_mach_X`,
+                // standalone `standalone_mach_X`). statusInstanceId/loadConfig().machineId
+                // and the node's stored daemonId/machineId frequently hold DIFFERENT forms
+                // of the same machine, so a raw `===` would miss the self-match and let the
+                // coordinator delete its own live base node (the very accident this guard
+                // exists to prevent). daemonIdsEquivalent collapses every form to its
+                // machine core before comparing, so a same-machine match is caught
+                // regardless of which form each side carries. This only widens matches
+                // (every raw-`===` hit still matches) — fail-open → fail-closed.
                 const isCoordinatorBaseNode =
-                    (!!selfDaemonId && (nodeDaemonId === selfDaemonId || nodeMachineId === selfDaemonId))
-                    || (!!selfMachineId && (nodeDaemonId === selfMachineId || nodeMachineId === selfMachineId));
+                    (!!selfDaemonId && (daemonIdsEquivalent(nodeDaemonId, selfDaemonId) || daemonIdsEquivalent(nodeMachineId, selfDaemonId)))
+                    || (!!selfMachineId && (daemonIdsEquivalent(nodeDaemonId, selfMachineId) || daemonIdsEquivalent(nodeMachineId, selfMachineId)));
                 if (isCoordinatorBaseNode) {
                     return {
                         success: false,

package/src/commands/router.ts

@@ -1216,6 +1216,51 @@ export function buildMeshNodeDataFreshness(args: {
     };
 }
 
+/**
+ * Canonical live-probe → freshness adapter. The coordinator-facing mesh_status
+ * (mcp-server `meshStatus`) builds each node entry from a SINGLE fresh git_status
+ * probe that either returns (live truth) or throws (peer unreachable). It used to
+ * hand-reconstruct the freshness INPUT inline — a synthetic `{ git, connection }`
+ * status plus the directTruthUnavailable/liveTruthProbed wiring — which is exactly
+ * how a field added to `buildMeshNodeDataFreshness`'s input contract ends up "wired
+ * on the daemon surface, null on the coordinator surface" (the rc.371
+ * null-everywhere regression). Routing every live-probe surface through this one
+ * adapter keeps the marker derivation canonical: there is a SINGLE place that turns
+ * a probe outcome into freshness args, so the two mesh_status surfaces cannot drift.
+ *
+ * `liveTruthProbed` true → the probe returned (live/self truth); false → it threw,
+ * so a configured peer is unreachable while an unconfigured node (no daemonId) falls
+ * through to the classifier's `unconfigured` branch.
+ */
+export function buildMeshNodeProbeFreshness(args: {
+    /** The git snapshot this probe stamped on the node entry (entry.git). */
+    git: unknown;
+    /** True when the fresh git_status probe RETURNED (live truth); false when it threw. */
+    liveTruthProbed: boolean;
+    isSelfNode: boolean;
+    /** The node's resolved daemonId; absent → unconfigured node. */
+    daemonId?: string;
+    /** The mesh node record, for held-git fallback when the probe did not return live. */
+    node?: any;
+    now?: () => number;
+}): Record<string, unknown> {
+    const { git, liveTruthProbed, isSelfNode, daemonId, node, now } = args;
+    const status: Record<string, unknown> = {
+        git,
+        connection: { state: liveTruthProbed ? 'connected' : 'disconnected' },
+    };
+    if (liveTruthProbed) status[MESH_NODE_LIVE_TRUTH_MARKER] = true;
+    return buildMeshNodeDataFreshness({
+        status,
+        node,
+        isSelfNode,
+        daemonId,
+        liveTruthProbed,
+        directTruthUnavailable: !liveTruthProbed && !!daemonId,
+        now,
+    });
+}
+
 export function finalizeMeshNodeStatus(args: {
     status: Record<string, unknown>;
     node: any;

package/src/index.ts

@@ -312,7 +312,7 @@ export type { CdpInitializerConfig } from './cdp/initializer.js';
 // ── Commands ──
 export { DaemonCommandHandler } from './commands/handler.js';
 export type { CommandResult, CommandContext } from './commands/handler.js';
-export { DaemonCommandRouter, readCachedInlineMeshActiveSessionDetails, resolveMeshNodeAttribution, buildMeshNodeDataFreshness, MESH_NODE_LIVE_TRUTH_MARKER } from './commands/router.js';
+export { DaemonCommandRouter, readCachedInlineMeshActiveSessionDetails, resolveMeshNodeAttribution, buildMeshNodeDataFreshness, buildMeshNodeProbeFreshness, MESH_NODE_LIVE_TRUTH_MARKER } from './commands/router.js';
 export type { CommandRouterDeps, CommandRouterResult } from './commands/router.js';
 export {
   maybeRunDaemonUpgradeHelperFromEnv,

package/src/logging/log-tail-reader.ts

@@ -7,7 +7,21 @@
  * grep the file by hand. Because the mesh RPC envelope is sent as a single
  * datachannel message (~256KB SCTP ceiling, no chunking), the returned tail is
  * HARD-bounded by `tailBytes` (default 64KB, capped at MAX_TAIL_BYTES=128KB) and
- * flags `truncated:true` when the file was larger.
+ * flags `truncated:true` when more content existed than fit.
+ *
+ * Two read modes:
+ *  - No filter (no grep/sinceMs): byte-bounded tail of the active file — read the
+ *    last `tailBytes` bytes only. Cheap, backward-compatible.
+ *  - Filtered (grep and/or sinceMs given): FULL-FILE scan. The filter is applied
+ *    across the ENTIRE file (plus the size-rotation `.1.log` backup) BEFORE the
+ *    byte cap, then the last `tailBytes` worth of MATCHING lines are returned.
+ *    This is the fix for "matches hidden behind polling spam": when the recent
+ *    tail window is saturated with high-frequency lines (e.g. coordinator polling
+ *    `get_pending_mesh_events`/`read_chat` every few seconds), a grep for a rarer
+ *    earlier line (dispatch/inject/forward) previously matched 0 because the line
+ *    had already scrolled out of the tail window before the filter ran. Filtering
+ *    the whole file first surfaces those matches regardless of how much unrelated
+ *    spam followed them.
  *
  * Boundary-safe: lines are cut on the newline byte (0x0A) only, which never
  * appears inside a multibyte UTF-8 sequence, so decoding each complete byte
@@ -36,14 +50,27 @@ export interface DaemonLogTailResult {
     success: boolean;
     error?: string;
     lines: string[];
+    /**
+     * No-filter mode: true when the file was larger than the byte window.
+     * Filter mode: true when matching lines were dropped from the FRONT to fit
+     * the byte cap (i.e. there are older matches than the ones returned).
+     */
     truncated: boolean;
     logPath: string;
     platform: NodeJS.Platform;
     bytesReturned: number;
-    /** True when a grep/since filter dropped lines from the raw tail window. */
+    /** True when a grep/since filter dropped at least one line. */
     filtered: boolean;
     /** The grep source actually applied (echoed back for clarity). */
     grep?: string;
+    /** True when the filtered full-file scan path ran (grep/sinceMs given). */
+    fullScan: boolean;
+    /** Total bytes read while scanning (filter mode scans the whole file + backup). */
+    scannedBytes: number;
+    /** Number of lines that matched the filter across the full scan (filter mode). */
+    matchedLineCount: number;
+    /** Number of scanned lines dropped by the filter ("N lines excluded by filter"). */
+    excludedByFilter: number;
 }
 
 function resolveLogPath(date?: string | Date): string {
@@ -102,6 +129,39 @@ function readByteBoundedTail(filePath: string, limitBytes: number): { text: stri
     }
 }
 
+/** Split decoded text into lines, dropping the trailing empty element a final
+ * newline produces. Pure helper shared by both read modes. */
+function splitLogLines(text: string): string[] {
+    const lines = text.split('\n');
+    if (lines.length && lines[lines.length - 1] === '') lines.pop();
+    return lines;
+}
+
+/**
+ * Keep the LAST lines whose cumulative UTF-8 byte size (counting one byte per
+ * line for the joining newline) stays within `limitBytes`. Always keeps at least
+ * the final line, even if it alone exceeds the cap (matches the no-filter path's
+ * "never return nothing when there is content" behaviour). `truncated` is true
+ * when earlier lines were dropped to fit.
+ */
+function takeLastLinesWithinBytes(lines: string[], limitBytes: number): { kept: string[]; truncated: boolean; bytesReturned: number } {
+    if (lines.length === 0) return { kept: [], truncated: false, bytesReturned: 0 };
+    let total = 0;
+    let firstKept = lines.length;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        const lineBytes = Buffer.byteLength(lines[i], 'utf-8') + 1; // +1 ≈ joining newline
+        // Once at least one line is kept, stop before overflowing the cap.
+        if (firstKept !== lines.length && total + lineBytes > limitBytes) break;
+        total += lineBytes;
+        firstKept = i;
+    }
+    return {
+        kept: lines.slice(firstKept),
+        truncated: firstKept > 0,
+        bytesReturned: total,
+    };
+}
+
 // Parse a leading timestamp from a log line into epoch ms. The unified logger
 // writes `[HH:MM:SS.mmm]` (local time, today's date) and the startup banner uses
 // a full timestamp; we best-effort parse `[HH:MM:SS...]` against the file's date.
@@ -122,99 +182,160 @@ function parseLineEpochMs(line: string, fileDate: Date): number | null {
     return d.getTime();
 }
 
+/** Build the case-insensitive line predicate for a grep source, falling back to
+ * a literal (lowercased substring) match when the source is not a valid regex. */
+function buildGrepPredicate(grepSource: string): (line: string) => boolean {
+    let re: RegExp | null = null;
+    try {
+        re = new RegExp(grepSource, 'i');
+    } catch {
+        re = null;
+    }
+    if (re) {
+        const compiled = re;
+        return (line: string) => compiled.test(line);
+    }
+    const needle = grepSource.toLowerCase();
+    return (line: string) => line.toLowerCase().includes(needle);
+}
+
+function fileDateFor(date?: string | Date): Date {
+    if (date instanceof Date) return date;
+    if (typeof date === 'string' && date.trim()) return new Date(`${date.trim()}T00:00:00.000Z`);
+    return new Date();
+}
+
+function errorResult(error: string, logPath: string, platform: NodeJS.Platform): DaemonLogTailResult {
+    return {
+        success: false,
+        error,
+        lines: [],
+        truncated: false,
+        logPath,
+        platform,
+        bytesReturned: 0,
+        filtered: false,
+        fullScan: false,
+        scannedBytes: 0,
+        matchedLineCount: 0,
+        excludedByFilter: 0,
+    };
+}
+
 /**
- * Read the daemon log tail for `date` (default today), bounded to `tailBytes`,
- * with optional grep (regex source) and sinceMs filters. Falls back to the
- * size-rotation backup (`*.1.log`) when the primary file does not exist.
+ * Read the daemon log tail for `date` (default today), bounded to `tailBytes`.
+ *
+ * - No grep/sinceMs → byte-bounded tail of the active file (legacy behaviour).
+ * - grep and/or sinceMs given → FULL-FILE scan: the filter is applied across the
+ *   whole file (plus the `*.1.log` size-rotation backup) BEFORE the byte cap, so
+ *   matches that have scrolled out of the recent tail window (e.g. behind
+ *   coordinator polling spam) are still returned. Only the last `tailBytes` worth
+ *   of matching lines ship over P2P.
+ *
+ * Falls back to the size-rotation backup (`*.1.log`) when the primary file does
+ * not exist.
  */
 export function readDaemonLogTail(args: ReadDaemonLogTailArgs = {}): DaemonLogTailResult {
     const platform = process.platform;
     const limitBytes = clampTailBytes(args.tailBytes);
-    let logPath = resolveLogPath(args.date);
-
-    // Fall back to the size-rotation backup if the active file is absent.
-    if (!fs.existsSync(logPath)) {
-        const backup = logPath.replace(/\.log$/, '.1.log');
-        if (fs.existsSync(backup)) {
-            logPath = backup;
-        } else {
-            return {
-                success: false,
-                error: `No daemon log file at ${logPath} (dir: ${getDaemonLogDir()})`,
-                lines: [],
-                truncated: false,
-                logPath,
-                platform,
-                bytesReturned: 0,
-                filtered: false,
-            };
-        }
+    const primaryPath = resolveLogPath(args.date);
+    const backupPath = primaryPath.replace(/\.log$/, '.1.log');
+    const primaryExists = fs.existsSync(primaryPath);
+    const backupExists = fs.existsSync(backupPath);
+
+    if (!primaryExists && !backupExists) {
+        return errorResult(
+            `No daemon log file at ${primaryPath} (dir: ${getDaemonLogDir()})`,
+            primaryPath,
+            platform,
+        );
     }
 
-    let raw: { text: string; truncated: boolean; bytesReturned: number };
-    try {
-        raw = readByteBoundedTail(logPath, limitBytes);
-    } catch (e: any) {
+    // Reported log path: the active file when present, else the backup.
+    const logPath = primaryExists ? primaryPath : backupPath;
+
+    const hasGrep = typeof args.grep === 'string' && args.grep.trim().length > 0;
+    const hasSince = Number.isFinite(args.sinceMs);
+    const filterMode = hasGrep || hasSince;
+
+    // ── No-filter mode: cheap byte-bounded tail of the active file ──────────
+    if (!filterMode) {
+        let raw: { text: string; truncated: boolean; bytesReturned: number };
+        try {
+            raw = readByteBoundedTail(logPath, limitBytes);
+        } catch (e: any) {
+            return errorResult(`Failed to read ${logPath}: ${e?.message ?? String(e)}`, logPath, platform);
+        }
+        const lines = splitLogLines(raw.text);
         return {
-            success: false,
-            error: `Failed to read ${logPath}: ${e?.message ?? String(e)}`,
-            lines: [],
-            truncated: false,
+            success: true,
+            lines,
+            truncated: raw.truncated,
             logPath,
             platform,
-            bytesReturned: 0,
+            bytesReturned: raw.bytesReturned,
             filtered: false,
+            fullScan: false,
+            scannedBytes: raw.bytesReturned,
+            matchedLineCount: lines.length,
+            excludedByFilter: 0,
         };
     }
 
-    let lines = raw.text.split('\n');
-    // A trailing newline yields a final empty element — drop it.
-    if (lines.length && lines[lines.length - 1] === '') lines.pop();
-    const rawCount = lines.length;
-
-    // since filter
-    if (Number.isFinite(args.sinceMs)) {
-        const fileDate = args.date instanceof Date
-            ? args.date
-            : typeof args.date === 'string' && args.date.trim()
-                ? new Date(`${args.date.trim()}T00:00:00.000Z`)
-                : new Date();
+    // ── Filter mode: scan the WHOLE file (backup then primary, chronological)
+    // so matches behind a saturated tail window are still found. ────────────
+    let scannedBytes = 0;
+    let allLines: string[] = [];
+    try {
+        for (const p of [backupExists ? backupPath : null, primaryExists ? primaryPath : null]) {
+            if (!p) continue;
+            const buf = fs.readFileSync(p);
+            scannedBytes += buf.length;
+            allLines = allLines.concat(splitLogLines(buf.toString('utf-8')));
+        }
+    } catch (e: any) {
+        return errorResult(`Failed to read ${logPath}: ${e?.message ?? String(e)}`, logPath, platform);
+    }
+
+    const scannedLineCount = allLines.length;
+    let lines = allLines;
+
+    // since filter — keep lines at/after the floor (and lines with no timestamp).
+    if (hasSince) {
+        const fileDate = fileDateFor(args.date);
         const floor = args.sinceMs as number;
         lines = lines.filter((line) => {
             const ts = parseLineEpochMs(line, fileDate);
-            // Keep lines with no parseable timestamp (continuation/stack lines).
             return ts === null || ts >= floor;
         });
     }
 
     // grep filter
     let appliedGrep: string | undefined;
-    if (typeof args.grep === 'string' && args.grep.trim()) {
-        appliedGrep = args.grep.trim();
-        let re: RegExp | null = null;
-        try {
-            re = new RegExp(appliedGrep, 'i');
-        } catch {
-            re = null;
-        }
-        if (re) {
-            const compiled = re;
-            lines = lines.filter((line) => compiled.test(line));
-        } else {
-            // Invalid regex → fall back to a literal substring match.
-            const needle = appliedGrep.toLowerCase();
-            lines = lines.filter((line) => line.toLowerCase().includes(needle));
-        }
+    if (hasGrep) {
+        appliedGrep = (args.grep as string).trim();
+        const matches = buildGrepPredicate(appliedGrep);
+        lines = lines.filter(matches);
     }
 
+    const matchedLineCount = lines.length;
+    const excludedByFilter = scannedLineCount - matchedLineCount;
+
+    // Byte cap applies to the MATCHING lines: keep the newest matches that fit.
+    const capped = takeLastLinesWithinBytes(lines, limitBytes);
+
     return {
         success: true,
-        lines,
-        truncated: raw.truncated,
+        lines: capped.kept,
+        truncated: capped.truncated,
         logPath,
         platform,
-        bytesReturned: raw.bytesReturned,
-        filtered: lines.length !== rawCount,
+        bytesReturned: capped.bytesReturned,
+        filtered: excludedByFilter > 0,
+        fullScan: true,
+        scannedBytes,
+        matchedLineCount,
+        excludedByFilter,
         ...(appliedGrep ? { grep: appliedGrep } : {}),
     };
 }

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

@@ -23,6 +23,7 @@ import type { RepoMeshSchedulingStrategy } from '../repo-mesh-types.js';
 import { normalizeMeshNodeId, meshNodeIdMatches, daemonIdsEquivalent, expandDaemonIdForms, normalizeMeshWorkspaceForCompare, meshWorkspacesEquivalent, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 import {
     findRecentTerminalLedgerEvidence,
+    findTerminalLedgerEvidenceForTask,
     hasDispatchAfterTerminal,
     hasUnterminalDirectDispatchLedgerEntry,
     buildNoProgressCompletionReconciliation,
@@ -654,6 +655,24 @@ export function tryAssignQueueTask(
         return false;
     }
 
+    const terminal = findTerminalLedgerEvidenceForTask({
+        meshId,
+        taskId: task.id,
+    });
+    if (terminal) {
+        const status = terminal.kind === 'task_completed' ? 'completed' : 'failed';
+        updateTaskStatus(meshId, task.id, status);
+        LOG.info('MeshQueue', `Skipped dispatch for terminal task ${task.id} on mesh ${meshId}; ${terminal.kind} ledger evidence already exists`);
+        traceMeshEventDrop('dispatch_terminal_ledger', {
+            taskId: task.id,
+            sessionId,
+            nodeId,
+            meshId,
+            event: 'agent_command',
+        }, terminal.kind);
+        return false;
+    }
+
     LOG.info('MeshQueue', `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
 
     if (node?.daemonId && components.dispatchMeshCommand) {

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

@@ -85,6 +85,29 @@ function isWeakCompletionLedgerPayload(payload: Record<string, unknown> | undefi
     return diag?.finalAssistantPresent === false || diag?.blockReason === 'missing_final_assistant';
 }
 
+export function findTerminalLedgerEvidenceForTask(args: {
+    meshId: string;
+    taskId?: string;
+    sessionId?: string;
+    nodeId?: string;
+    tail?: number;
+}): { id: string; kind: Extract<MeshLedgerKind, 'task_completed' | 'task_failed' | 'task_stalled'>; payload: Record<string, unknown>; timestamp: string } | null {
+    const taskId = readNonEmptyString(args.taskId);
+    if (!taskId) return null;
+    const entries = readLedgerEntries(args.meshId, { tail: args.tail ?? 500 });
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const entry = entries[i];
+        if (entry.kind !== 'task_completed' && entry.kind !== 'task_failed' && entry.kind !== 'task_stalled') continue;
+        const terminalTaskId = readNonEmptyString(entry.payload?.taskId);
+        if (terminalTaskId !== taskId) continue;
+        if (entry.kind === 'task_completed' && isWeakCompletionLedgerPayload(entry.payload)) continue;
+        if (args.sessionId && entry.sessionId && entry.sessionId !== args.sessionId) continue;
+        if (!args.sessionId && args.nodeId && entry.nodeId && !meshNodeIdMatches(entry as unknown as MeshNodeIdentified, args.nodeId)) continue;
+        return { id: entry.id, kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
+    }
+    return null;
+}
+
 function findDirectDispatchLedgerEntry(args: {
     meshId: string;
     taskId: string;

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

@@ -109,7 +109,7 @@ const MESH_SURFACED_PREVIEW_MAX_CHARS = 512;
 // coordinator-facing payload that replaces a "go call mesh_read_chat" instruction —
 // it should carry enough of the worker's result to act on without a second round-trip,
 // while still bounding what is written into the coordinator PTY.
-const MESH_COMPLETION_SURFACE_MAX_CHARS = 4000;
+const MESH_COMPLETION_SURFACE_MAX_CHARS = 16000;
 
 /**
  * The worker's final assistant text carried on a completion event — read from