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

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.373",
+  "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.373",
+    "@adhdev/mesh-shared": "0.9.82-rc.374",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

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/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

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

@@ -58,10 +58,10 @@ import {
 import { readNonEmptyString, readMeshCompletionSummary } from './mesh-events-utils.js';
 import { traceMeshEventStage, traceMeshEventDrop } from './mesh-event-trace.js';
 import { expandDaemonIdForms, daemonIdsEquivalent } from '@adhdev/mesh-shared';
-import { getActiveDirectDispatches, getQueue, reclaimStrandedAssignedTask } from './mesh-work-queue.js';
+import { getActiveDirectDispatches, getQueue, reclaimStrandedAssignedTask, updateTaskStatus } 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 { findTerminalLedgerEvidenceForTask, reconcileDirectDispatchCompletionFromTranscript } from './mesh-events-stale.js';
 import { extractFinalAssistantSummaryEvidence } from '../providers/chat-message-normalization.js';
 import type { ChatMessage } from '../types.js';
 
@@ -164,7 +164,12 @@ function daemonHostsMesh(mesh: LocalMeshEntry, daemonIds: string[]): boolean {
     const hostDaemonId = readNonEmptyString(host.hostDaemonId);
     // Host role but no pinned hostDaemonId → treat as host (single-daemon / legacy).
     if (!hostDaemonId) return true;
-    return daemonIds.includes(hostDaemonId);
+    return daemonIdListIncludes(daemonIds, hostDaemonId);
+}
+
+function daemonIdListIncludes(ids: readonly string[], id: string | undefined): boolean {
+    if (!id) return false;
+    return ids.some(candidate => candidate === id || daemonIdsEquivalent(candidate, id));
 }
 
 // Resolve EVERY id-form this daemon answers to FOR A GIVEN MESH: the runtime drain
@@ -183,8 +188,8 @@ function resolveCoordinatorSelfIds(mesh: LocalMeshEntry, drainDaemonIds: string[
     for (const node of mesh.nodes) {
         const nodeDaemonId = readNonEmptyString(node.daemonId);
         const nodeMachineId = readNonEmptyString(node.machineId);
-        const isSelf = (nodeDaemonId && drainDaemonIds.includes(nodeDaemonId))
-            || (nodeMachineId && drainDaemonIds.includes(nodeMachineId));
+        const isSelf = (nodeDaemonId && daemonIdListIncludes(drainDaemonIds, nodeDaemonId))
+            || (nodeMachineId && daemonIdListIncludes(drainDaemonIds, nodeMachineId));
         if (!isSelf) continue;
         if (nodeDaemonId) ids.add(nodeDaemonId);
         if (nodeMachineId) ids.add(nodeMachineId);
@@ -196,7 +201,7 @@ function resolveCoordinatorSelfIds(mesh: LocalMeshEntry, drainDaemonIds: string[
     // this daemon does not make this daemon the host; daemonHostsMesh still honours a
     // foreign hostDaemonId and rejects ownership.
     const hostDaemonId = readNonEmptyString(mesh.meshHost?.hostDaemonId);
-    if (hostDaemonId && ids.has(hostDaemonId)) ids.add(hostDaemonId);
+    if (hostDaemonId && daemonIdListIncludes([...ids], hostDaemonId)) ids.add(hostDaemonId);
     return [...ids];
 }
 
@@ -358,6 +363,23 @@ function recoverStrandedAssignedDispatches(meshId: string, store: MeshRuntimeSto
         const dispatchedAtMs = Date.parse(row.dispatchTimestamp ?? '');
         if (!Number.isFinite(dispatchedAtMs)) continue;              // no dispatch ts → can't age it
         if (nowMs - dispatchedAtMs < ASSIGNED_STRANDED_DEADLINE_MS) continue;  // still in confirm window
+        const terminal = findTerminalLedgerEvidenceForTask({
+            meshId,
+            taskId: row.id,
+        });
+        if (terminal) {
+            const status = terminal.kind === 'task_completed' ? 'completed' : 'failed';
+            updateTaskStatus(meshId, row.id, status);
+            LOG.warn('MeshReconcile', `Skipped stranded reclaim redispatch for terminal task ${row.id} on mesh ${meshId}; ${terminal.kind} ledger evidence already exists`);
+            traceMeshEventDrop('assigned_stranded_terminal_ledger', {
+                taskId: row.id,
+                sessionId: row.assignedSessionId,
+                nodeId: row.assignedNodeId,
+                meshId,
+                event: 'agent:generating_completed',
+            }, terminal.kind);
+            continue;
+        }
         if (store.taskHasConfirmedDelivery(meshId, row.id)) continue;          // dispatched → PHASE 4's job
         const reclaimed = reclaimStrandedAssignedTask(meshId, row.id, {
             reason: 'assigned_stranded_dispatch_unconfirmed',
@@ -896,7 +918,7 @@ async function pullRemoteNodeQueues(
         // from ourselves over P2P is both wasteful and a self-dispatch hazard.
         if (!nodeDaemonId) continue;
         if (daemonIdsEquivalent(nodeDaemonId, localDaemonId)) continue;
-        if (candidateDaemonIds.includes(nodeDaemonId)) continue;
+        if (daemonIdListIncludes(candidateDaemonIds, nodeDaemonId)) continue;
 
         for (const pendingEventArgs of pulls) {
             let events: unknown;
@@ -972,7 +994,7 @@ async function reconcileUnterminatedDirectDispatches(
         // A node is local when it has no daemonId, names this daemon, or actually
         // has a live instance here. Anything else is reached over P2P.
         const isLocalNode = !nodeDaemonId
-            || selfIds.includes(nodeDaemonId)
+            || daemonIdListIncludes(selfIds, nodeDaemonId)
             || daemonIdsEquivalent(nodeDaemonId, localDaemonId)
             || !!components.instanceManager.getInstance(sessionId);
 
@@ -1092,7 +1114,7 @@ async function collectLiveNodesWithSessions(
     return Promise.all(mesh.nodes.map(async (node) => {
         const nodeDaemonId = readNonEmptyString(node.daemonId);
         const isLocalNode = !nodeDaemonId
-            || selfIds.includes(nodeDaemonId)
+            || daemonIdListIncludes(selfIds, nodeDaemonId)
             || daemonIdsEquivalent(nodeDaemonId, localDaemonId);
         let statusResult: unknown;
         try {

package/src/providers/chat-message-normalization.ts

@@ -1,7 +1,7 @@
 import type { ChatMessage } from '../types.js';
 import { flattenContent } from './contracts.js';
 
-export const DEFAULT_FINAL_SUMMARY_MAX_CHARS = 4_000;
+export const DEFAULT_FINAL_SUMMARY_MAX_CHARS = 16_000;
 
 export function extractFinalSummaryFromMessages(
   messages: ChatMessage[] | null | undefined,