@adhdev/daemon-core 0.9.82-rc.487 → 0.9.82-rc.488

package/dist/mesh/mesh-event-forwarding.d.ts

@@ -13,12 +13,21 @@ export declare function handleMeshForwardEvent(components: DaemonComponents, pay
     forwarded: number;
     suppressed: boolean;
     autoApprovingWorkerApproval: boolean;
+    staleDispatchRejected?: undefined;
+    error?: undefined;
+} | {
+    success: boolean;
+    forwarded: number;
+    suppressed: boolean;
+    staleDispatchRejected: boolean;
+    autoApprovingWorkerApproval?: undefined;
     error?: undefined;
 } | {
     success: boolean;
     forwarded: number;
     suppressed?: undefined;
     autoApprovingWorkerApproval?: undefined;
+    staleDispatchRejected?: undefined;
     error?: undefined;
 } | {
     success: boolean;

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

@@ -179,6 +179,17 @@ export interface MeshWorkQueueEntry {
     };
     /** ISO timestamp when the task was dispatched (assigned) to a node/session. Used for precise matching on completion. */
     dispatchTimestamp?: string;
+    /**
+     * REDRIVE-DUP: monotonic per-task dispatch nonce. Bumped on every (re)dispatch of
+     * this task (assignQueueTask) AND on every reclaim (reclaimStrandedAssignedTask), and
+     * carried to the worker in meshContext.dispatchNonce. The worker echoes it back on
+     * agent:generating_started (metadataEvent.dispatchNonce). When a delivered-not-consumed
+     * task is reclaimed and re-dispatched to a different node, the ORIGINAL inject to the
+     * first node still carries the now-stale nonce; the coordinator rejects that node's
+     * generating_started ack (and stops it) so the SAME taskId is never executed twice.
+     * Absent on legacy rows → the coordinator skips the stale-nonce guard (backward safe).
+     */
+    dispatchNonce?: number;
     /**
      * (3) The ORIGINATING coordinator session that enqueued this task. Stamped onto the
      * worker at dispatch (meshCoordinatorSessionId) so the task's completion routes back to

package/dist/providers/cli-provider-instance.d.ts

@@ -201,6 +201,7 @@ export declare class CliProviderInstance implements ProviderInstance {
         meshId: string;
         nodeId?: string;
         taskId?: string;
+        dispatchNonce?: number;
         coordinatorDaemonId?: string;
         coordinatorSessionId?: string;
     }): void;

package/dist/providers/provider-instance-manager.d.ts

@@ -92,6 +92,7 @@ export declare class ProviderInstanceManager {
         meshId: string;
         nodeId?: string;
         taskId?: string;
+        dispatchNonce?: number;
         coordinatorDaemonId?: string;
         coordinatorSessionId?: string;
     }): {

package/dist/providers/provider-instance.d.ts

@@ -188,6 +188,7 @@ export interface ProviderInstance {
         meshId: string;
         nodeId?: string;
         taskId?: string;
+        dispatchNonce?: number;
         coordinatorDaemonId?: string;
         coordinatorSessionId?: string;
     }): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.487",
+  "version": "0.9.82-rc.488",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,8 +47,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.487",
-    "@adhdev/session-host-core": "0.9.82-rc.487",
+    "@adhdev/mesh-shared": "0.9.82-rc.488",
+    "@adhdev/session-host-core": "0.9.82-rc.488",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/commands/cli-manager.ts

@@ -1725,6 +1725,10 @@ export class DaemonCliManager {
                                 meshId: meshContext.meshId,
                                 ...(typeof meshContext.nodeId === 'string' && meshContext.nodeId ? { nodeId: meshContext.nodeId } : {}),
                                 ...(typeof meshContext.taskId === 'string' && meshContext.taskId ? { taskId: meshContext.taskId } : {}),
+                                // REDRIVE-DUP: carry the dispatch nonce onto the worker session so
+                                // its generating_started event echoes it back for the coordinator's
+                                // stale-nonce guard.
+                                ...(typeof meshContext.dispatchNonce === 'number' ? { dispatchNonce: meshContext.dispatchNonce } : {}),
                                 ...(typeof meshContext.coordinatorDaemonId === 'string' && meshContext.coordinatorDaemonId ? { coordinatorDaemonId: meshContext.coordinatorDaemonId } : {}),
                             });
                         } catch { /* best-effort — stamping is a routing aid, not a hard requirement */ }

package/src/commands/router-refine.ts

@@ -82,7 +82,65 @@ export function buildRefineJobHandle(self: DaemonCommandRouter, args: {
         };
     }
 
+/**
+ * Slim the terminal-stage refine result down to the fields a coordinator needs to
+ * decide next-step, dropping the heavy per-command / per-entry detail.
+ *
+ * The full `CommandRouterResult` (with `validationSummary.commandsRun[]` carrying
+ * per-command stdout/stderr, `rejectedCommands`, `suggestions`, `suggestedConfig`,
+ * the full `patchEquivalence`, and `submoduleReachability.entries[]`/`.unreachable[]`)
+ * routinely exceeds 70KB and overflows the coordinator token limit when it rides on a
+ * `mesh_wait_events` payload. The full detail is still persisted verbatim to the ledger
+ * (`appendRefineJobLedger`) and `terminalRefineJobs`, so slimming only the EVENT loses
+ * nothing — the coordinator can pull the full record on demand via
+ * `evidence.ledgerCommand` / `taskHistoryKind`.
+ */
+export function slimRefineEventResult(result: Record<string, unknown>): Record<string, unknown> {
+        const slim: Record<string, unknown> = {};
+        // Top-level scalars the coordinator branches on.
+        for (const key of [
+            'success', 'code', 'error', 'convergenceStatus', 'blockedReason',
+            'branch', 'into', 'terminalKind', 'nextStep', 'finalBranchConvergenceState',
+        ] as const) {
+            if (result[key] !== undefined) slim[key] = result[key];
+        }
+        // Mapped subset of the unreachable-submodule commits (path + autoPublishAllowed),
+        // not the full commit records.
+        if (Array.isArray(result.unreachableSubmoduleCommits)) {
+            slim.unreachableSubmoduleCommits = (result.unreachableSubmoduleCommits as Array<Record<string, unknown>>)
+                .map(e => ({ path: e?.path, autoPublishAllowed: e?.autoPublishAllowed }));
+        }
+        // Reduced validation summary — status + failure classification + config source
+        // + a count of commands run (drop the full commandsRun/rejectedCommands/
+        // suggestions/suggestedConfig detail).
+        if (result.validationSummary && typeof result.validationSummary === 'object') {
+            const vs = result.validationSummary as Record<string, unknown>;
+            slim.validationSummary = {
+                status: vs.status,
+                failureCode: vs.failureCode,
+                configSource: vs.configSource,
+                configSourceType: vs.configSourceType,
+                commandsRunCount: Array.isArray(vs.commandsRun) ? vs.commandsRun.length : undefined,
+            };
+        }
+        // Reduce patch-equivalence to just its verdict.
+        if (result.patchEquivalence && typeof result.patchEquivalence === 'object') {
+            const pe = result.patchEquivalence as Record<string, unknown>;
+            slim.patchEquivalence = { status: pe.status, equivalent: pe.equivalent };
+        }
+        // Reduce submodule reachability to counts; drop the full entries/unreachable arrays.
+        if (result.submoduleReachability && typeof result.submoduleReachability === 'object') {
+            const sr = result.submoduleReachability as Record<string, unknown>;
+            slim.submoduleReachability = {
+                checked: Array.isArray(sr.entries) ? sr.entries.length : undefined,
+                unreachable: Array.isArray(sr.unreachable) ? sr.unreachable.length : undefined,
+            };
+        }
+        return slim;
+}
+
 export function queueRefineJobEvent(self: DaemonCommandRouter, event: 'refine:accepted' | 'refine:completed' | 'refine:failed', handle: MeshRefineJobHandle, result?: Record<string, unknown>): void {
+        const slimResult = result ? slimRefineEventResult(result) : undefined;
         const metadataEvent = {
             source: 'refine_mesh_node_async_job',
             jobId: handle.jobId,
@@ -95,7 +153,7 @@ export function queueRefineJobEvent(self: DaemonCommandRouter, event: 'refine:ac
             startedAt: handle.startedAt,
             completedAt: handle.completedAt,
             retryOfJobId: handle.retryOfJobId,
-            ...(result ? { result } : {}),
+            ...(slimResult ? { result: slimResult } : {}),
         };
         const eventPayload = {
             event,
@@ -122,7 +180,7 @@ export function queueRefineJobEvent(self: DaemonCommandRouter, event: 'refine:ac
                     startedAt: handle.startedAt,
                     completedAt: handle.completedAt,
                     retryOfJobId: handle.retryOfJobId,
-                    ...(result ? { result } : {}),
+                    ...(slimResult ? { result: slimResult } : {}),
                 },
             );
             if (forwarded?.success === true) return;

package/src/mesh/mesh-event-forwarding.ts

@@ -24,6 +24,7 @@ import {
     buildNoProgressCompletionReconciliation,
 } from './mesh-events-stale.js';
 import { endTaskDispatchInFlight } from './mesh-task-inflight.js';
+import { readMeshNodeDaemonId } from './mesh-node-identity.js';
 import {
     buildMeshSystemMessage,
     readNonEmptyString,
@@ -716,6 +717,58 @@ function sourceWorkerAutoApproves(components: DaemonComponents, sessionId: strin
     }
 }
 
+/**
+ * REDRIVE-DUP: stop a worker session that started a STALE (reclaimed) mesh dispatch,
+ * so it discards the reclaimed task before it double-executes it. Prefers the local
+ * transport when the session's adapter lives on this daemon; otherwise forwards a
+ * `stop_cli` to the worker node's daemon over P2P (best-effort — a failed stop only
+ * loses the belt-and-suspenders stop; the ack was already rejected, so the coordinator
+ * never treats the stale run as the authoritative execution).
+ */
+function stopStaleMeshWorker(
+    components: DaemonComponents,
+    args: { meshId: string; sessionId: string; nodeId?: string; providerType?: string; daemonId?: string },
+): void {
+    const { meshId, sessionId, providerType } = args;
+    const stopArgs: Record<string, unknown> = {
+        targetSessionId: sessionId,
+        ...(providerType ? { cliType: providerType } : {}),
+        mode: 'hard',
+        reason: 'stale_mesh_dispatch_reclaimed',
+    };
+    try {
+        const isLocal = components.cliManager?.adapters?.has?.(sessionId) === true;
+        if (isLocal) {
+            // cliType is required by stop_cli; resolve it from the local adapter when the
+            // event carried no providerType.
+            if (!stopArgs.cliType) {
+                const localType = components.cliManager?.adapters?.get?.(sessionId)?.cliType;
+                if (localType) stopArgs.cliType = localType;
+            }
+            Promise.resolve(components.cliManager?.handleCliCommand?.('stop_cli', stopArgs))
+                .catch((e: any) => LOG.warn('MeshQueue', `Local stop of stale worker ${sessionId} failed: ${e?.message || e}`));
+            return;
+        }
+        // Remote: resolve the worker node's daemon id (event metadata first, then the mesh node).
+        let daemonId = args.daemonId;
+        if (!daemonId && args.nodeId) {
+            try {
+                const mesh = getMeshWithCache(components, meshId);
+                const node = mesh?.nodes?.find((n: any) => meshNodeIdMatches(n, args.nodeId!));
+                daemonId = node ? readMeshNodeDaemonId(node) || undefined : undefined;
+            } catch { /* best-effort */ }
+        }
+        if (daemonId && components.dispatchMeshCommand) {
+            Promise.resolve(components.dispatchMeshCommand(daemonId, 'stop_cli', stopArgs))
+                .catch((e: any) => LOG.warn('MeshQueue', `Remote stop of stale worker ${sessionId} on daemon ${daemonId} failed: ${e?.message || e}`));
+        } else {
+            LOG.warn('MeshQueue', `Cannot stop stale worker ${sessionId}: no local adapter and no resolvable remote daemon id (node ${args.nodeId ?? '?'}). Ack already rejected — task will re-strand-and-fail if the worker completes.`);
+        }
+    } catch (e: any) {
+        LOG.warn('MeshQueue', `stopStaleMeshWorker error for ${sessionId}: ${e?.message || e}`);
+    }
+}
+
 function injectMeshSystemMessage(components: DaemonComponents, args: {
     meshId: string;
     sourceInstanceId?: string;
@@ -1115,6 +1168,45 @@ function injectMeshSystemMessage(components: DaemonComponents, args: {
             // sibling must keep that row 'dispatched' so its own confirm can match it; acking
             // by session would mark it 'acked' prematurely and hide a genuine non-delivery.
             const startedTaskId = readNonEmptyString(args.metadataEvent.taskId) || undefined;
+            // REDRIVE-DUP: reject a STALE dispatch. When a delivered-but-unconsumed task is
+            // reclaimed (reclaimStrandedAssignedTask) and re-dispatched to another node, the
+            // ORIGINAL inject to the first node is not cancelled — it can still fire and make
+            // that worker start the SAME taskId, double-executing it. The reclaim bumped the
+            // task row's dispatchNonce, so the stranded inject's generating_started echoes a
+            // nonce STRICTLY LESS than the row's current value. Detect that here: skip the ack
+            // (do NOT resurrect the row onto this stale session) and stop the worker so it
+            // discards the reclaimed task. A matching/greater nonce, or an absent nonce
+            // (legacy worker), falls through to the normal ack — backward safe.
+            const startedNonce = typeof args.metadataEvent.dispatchNonce === 'number'
+                ? args.metadataEvent.dispatchNonce
+                : undefined;
+            if (startedTaskId && startedNonce !== undefined) {
+                const currentRow = (() => {
+                    try { return MeshRuntimeStore.getInstance().findQueueEntryById(args.meshId, startedTaskId); }
+                    catch { return null; }
+                })();
+                const currentNonce = typeof currentRow?.dispatchNonce === 'number' ? currentRow.dispatchNonce : undefined;
+                if (currentNonce !== undefined && startedNonce < currentNonce) {
+                    LOG.warn('MeshQueue', `Rejecting stale mesh dispatch: task ${startedTaskId} generating_started from session ${sessionId} `
+                        + `(node ${nodeId ?? '?'}) carries dispatchNonce ${startedNonce} < current ${currentNonce} — the task was reclaimed and `
+                        + `re-dispatched; stopping this worker to prevent duplicate execution.`);
+                    traceMeshEventDrop('stale_dispatch_nonce_rejected', {
+                        taskId: startedTaskId,
+                        sessionId,
+                        nodeId,
+                        meshId: args.meshId,
+                        event: 'agent:generating_started',
+                    }, `nonce ${startedNonce} < ${currentNonce}`);
+                    stopStaleMeshWorker(components, {
+                        meshId: args.meshId,
+                        sessionId,
+                        nodeId,
+                        providerType: readNonEmptyString(args.metadataEvent.providerType) || readNonEmptyString(args.metadataEvent.cliType),
+                        daemonId: readNonEmptyString(args.metadataEvent.sourceDaemonId) || readNonEmptyString(args.metadataEvent.daemonId),
+                    });
+                    return { success: true, forwarded: 0, suppressed: true, staleDispatchRejected: true };
+                }
+            }
             // WARMUPGAP: only ack a dispatch row when the event names its task, or the session
             // currently holds an active assignment. A no-taskId generating_started from an
             // unassigned session is a pre-assignment warmup — the session_id fallback would ack a

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

@@ -588,6 +588,10 @@ export function tryAssignQueueTask(
                         meshId,
                         nodeId,
                         taskId: task.id,
+                        // REDRIVE-DUP: carry the current dispatch nonce so the worker can echo it
+                        // back on generating_started; a reclaim bumps this row's nonce, making an
+                        // already-in-flight stale inject rejectable on arrival.
+                        ...(typeof task.dispatchNonce === 'number' ? { dispatchNonce: task.dispatchNonce } : {}),
                         ...(localDaemonIdForDispatch ? { coordinatorDaemonId: localDaemonIdForDispatch } : {}),
                         ...(sourceCoordinatorSessionId ? { coordinatorSessionId: sourceCoordinatorSessionId } : {}),
                     },
@@ -668,6 +672,8 @@ export function tryAssignQueueTask(
                 meshId,
                 nodeId,
                 taskId: task.id,
+                // REDRIVE-DUP: carry the current dispatch nonce (see remote branch above).
+                ...(typeof task.dispatchNonce === 'number' ? { dispatchNonce: task.dispatchNonce } : {}),
                 ...(localCoordinatorDaemonId() ? { coordinatorDaemonId: localCoordinatorDaemonId() } : {}),
                 ...(readNonEmptyString(task.sourceCoordinatorSessionId) ? { coordinatorSessionId: readNonEmptyString(task.sourceCoordinatorSessionId) } : {}),
             },

package/src/mesh/mesh-runtime-store.ts

@@ -1043,6 +1043,11 @@ export class MeshRuntimeStore {
             entry.assignedSessionId = sessionId;
             if (providerType) entry.assignedProviderType = providerType;
             entry.dispatchTimestamp = now;
+            // REDRIVE-DUP: bump the per-task dispatch nonce on every claim so this dispatch
+            // carries a nonce strictly greater than any prior (reclaimed) dispatch of the same
+            // task. The worker echoes it on agent:generating_started; the coordinator rejects a
+            // stale-nonce ack so a reclaimed+re-dispatched task's original inject cannot execute.
+            entry.dispatchNonce = (entry.dispatchNonce || 0) + 1;
             entry.updatedAt = now;
 
             this.db.prepare(`

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

@@ -644,6 +644,17 @@ export interface MeshWorkQueueEntry {
     };
     /** ISO timestamp when the task was dispatched (assigned) to a node/session. Used for precise matching on completion. */
     dispatchTimestamp?: string;
+    /**
+     * REDRIVE-DUP: monotonic per-task dispatch nonce. Bumped on every (re)dispatch of
+     * this task (assignQueueTask) AND on every reclaim (reclaimStrandedAssignedTask), and
+     * carried to the worker in meshContext.dispatchNonce. The worker echoes it back on
+     * agent:generating_started (metadataEvent.dispatchNonce). When a delivered-not-consumed
+     * task is reclaimed and re-dispatched to a different node, the ORIGINAL inject to the
+     * first node still carries the now-stale nonce; the coordinator rejects that node's
+     * generating_started ack (and stops it) so the SAME taskId is never executed twice.
+     * Absent on legacy rows → the coordinator skips the stale-nonce guard (backward safe).
+     */
+    dispatchNonce?: number;
     /**
      * (3) The ORIGINATING coordinator session that enqueued this task. Stamped onto the
      * worker at dispatch (meshCoordinatorSessionId) so the task's completion routes back to
@@ -1386,6 +1397,13 @@ export function reclaimStrandedAssignedTask(
         delete entry.assignedSessionId;
         delete entry.assignedProviderType;
         delete entry.dispatchTimestamp;
+        // REDRIVE-DUP: bump the dispatch nonce so the ORIGINAL inject to prevNode/prevSession
+        // (which is delivered-but-unconsumed and about to be re-dispatched elsewhere) now
+        // carries a stale nonce. When that stranded inject finally fires and the worker emits
+        // agent:generating_started echoing the old nonce, the coordinator's stale-nonce guard
+        // rejects the ack and stops that worker — so the reclaimed+re-dispatched task is never
+        // executed by the originally-assigned session (no duplicate execution).
+        entry.dispatchNonce = (entry.dispatchNonce || 0) + 1;
         entry.strandedReclaimCount = reclaims;
         entry.updatedAt = now;
         // The stranded assignment is being torn down (→ pending or failed); end its

package/src/providers/cli-provider-instance.ts

@@ -825,7 +825,7 @@ export class CliProviderInstance implements ProviderInstance {
      * completion events silently drop because the forwarder has nothing to
      * match against.
      */
-    attachMeshAssignment(assignment: { meshId: string; nodeId?: string; taskId?: string; coordinatorDaemonId?: string; coordinatorSessionId?: string }): void {
+    attachMeshAssignment(assignment: { meshId: string; nodeId?: string; taskId?: string; dispatchNonce?: number; coordinatorDaemonId?: string; coordinatorSessionId?: string }): void {
         if (!assignment?.meshId) return;
         this.settings = {
             ...this.settings,
@@ -838,6 +838,10 @@ export class CliProviderInstance implements ProviderInstance {
             // shares this daemon. See isMeshOwnedDelegateSession's post-detach gate.
             ...(assignment.nodeId ? { meshNodeId: assignment.nodeId, meshLastNodeId: assignment.nodeId } : {}),
             ...(assignment.taskId ? { meshActiveTaskId: assignment.taskId } : {}),
+            // REDRIVE-DUP: task-level dispatch nonce, echoed on generating_started so the
+            // coordinator can reject a stale (reclaimed) dispatch. Cleared with meshActiveTaskId
+            // on detach so a subsequent unrelated turn never re-echoes a prior task's nonce.
+            ...(typeof assignment.dispatchNonce === 'number' ? { meshActiveDispatchNonce: assignment.dispatchNonce } : {}),
             ...(assignment.coordinatorDaemonId ? { meshCoordinatorDaemonId: assignment.coordinatorDaemonId } : {}),
             // Session-level routing anchor: the originating coordinator session, so this
             // worker's completion events route back to the exact session that dispatched it.
@@ -872,17 +876,18 @@ export class CliProviderInstance implements ProviderInstance {
      */
     detachMeshAssignment(): void {
         if (!this.settings.meshNodeFor && !this.settings.meshActiveTaskId && !this.settings.meshNodeId) return;
-        // Session-level member: keep membership, drop only the task-level marker.
+        // Session-level member: keep membership, drop only the task-level markers.
         if (this.settings.launchedByCoordinator === true) {
             if (!this.settings.meshActiveTaskId) return;
-            const { meshActiveTaskId, ...rest } = this.settings;
-            void meshActiveTaskId;
+            // REDRIVE-DUP: clear the task-level dispatch nonce with the task marker.
+            const { meshActiveTaskId, meshActiveDispatchNonce, ...rest } = this.settings;
+            void meshActiveTaskId; void meshActiveDispatchNonce;
             this.settings = rest;
             this.adapter.updateRuntimeSettings?.(this.settings);
             return;
         }
-        const { meshNodeFor, meshNodeId, meshActiveTaskId, ...rest } = this.settings;
-        void meshNodeFor; void meshActiveTaskId;
+        const { meshNodeFor, meshNodeId, meshActiveTaskId, meshActiveDispatchNonce, ...rest } = this.settings;
+        void meshNodeFor; void meshActiveTaskId; void meshActiveDispatchNonce;
         // WTCLAIM (A): clear the active binding but PRESERVE the last bound node id
         // (meshLastNodeId) so a later sessionless dispatch can re-adopt this idle
         // session ONLY for the node it last served. Carry the id being cleared, or
@@ -3189,6 +3194,12 @@ export class CliProviderInstance implements ProviderInstance {
                 const resolved = this.completingTurnTaskId();
                 if (resolved) enrichedEvent.taskId = resolved;
             }
+            // REDRIVE-DUP: echo the dispatch nonce this session's active task was stamped with
+            // so the coordinator's generating_started handler can reject a stale (reclaimed)
+            // dispatch and stop this worker before it double-executes the reclaimed task.
+            if (enrichedEvent.dispatchNonce === undefined && typeof this.settings.meshActiveDispatchNonce === 'number') {
+                enrichedEvent.dispatchNonce = this.settings.meshActiveDispatchNonce;
+            }
         }
         if (this.context?.emitProviderEvent) {
             this.context.emitProviderEvent(enrichedEvent);

package/src/providers/provider-instance-manager.ts

@@ -312,7 +312,7 @@ export class ProviderInstanceManager {
      *  applied, or `{ stamped: false, reason }` when it was refused — the instance
      *  was missing / has no attach method, or the DOUBLE-DISPATCH idempotence guard
      *  fired (the same task is already running on another live session here). */
-    attachMeshAssignmentToInstance(instanceId: string, assignment: { meshId: string; nodeId?: string; taskId?: string; coordinatorDaemonId?: string; coordinatorSessionId?: string }): { stamped: boolean; reason?: string } {
+    attachMeshAssignmentToInstance(instanceId: string, assignment: { meshId: string; nodeId?: string; taskId?: string; dispatchNonce?: number; coordinatorDaemonId?: string; coordinatorSessionId?: string }): { stamped: boolean; reason?: string } {
         const inst = this.instances.get(instanceId);
         if (!inst || typeof inst.attachMeshAssignment !== 'function') {
             LOG.warn('MeshDispatch', `attachMeshAssignment skipped: instance ${instanceId} ${inst ? 'has no attach method' : 'not found'}`);

package/src/providers/provider-instance.ts

@@ -220,7 +220,7 @@ export interface ProviderInstance {
     /** Stamp a direct-dispatch mesh task assignment so generating_completed
      *  events route back to the originating coordinator. Cleared by
      *  detachMeshAssignment when the task reaches a terminal state. */
-    attachMeshAssignment?(assignment: { meshId: string; nodeId?: string; taskId?: string; coordinatorDaemonId?: string; coordinatorSessionId?: string }): void;
+    attachMeshAssignment?(assignment: { meshId: string; nodeId?: string; taskId?: string; dispatchNonce?: number; coordinatorDaemonId?: string; coordinatorSessionId?: string }): void;
     detachMeshAssignment?(): void;
 
     /** Refresh static provider definition/scripts without restarting the live runtime. */