@adhdev/daemon-core 0.9.82-rc.486 → 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-refine-gates.d.ts

@@ -11,6 +11,7 @@
  * keep working. `CommandRouterResult` is imported type-only from router.ts
  * (erased at compile time — no runtime import cycle).
  */
+import type { ChangedPackageClassification } from '../git/git-status.js';
 import type { WorktreeBootstrapState } from '../mesh/worktree-bootstrap-config.js';
 import type { CommandRouterResult } from '../commands/router.js';
 export type MeshCoordinatorConfigFormat = 'claude_mcp_json' | 'hermes_config_yaml';
@@ -53,6 +54,19 @@ type MeshRefineValidationSummary = {
     };
     /** M2-2: deprecation notices from the refine config (e.g. bootstrapCommands). */
     deprecationWarnings?: string[];
+    /**
+     * Coarse daemon-vs-web change-impact used to scope the validation command set.
+     * When `isDaemonAffecting === false`, daemon-scoped commands are recorded in
+     * `commandsRun` with `skipped: true, skipReason: 'unaffected_daemon_scope'`
+     * rather than executed; web + typecheck commands always run. Absent when no
+     * change-impact was threaded in (legacy: full command set runs).
+     */
+    changeImpact?: {
+        isDaemonAffecting: boolean;
+        affectedPackages: string[];
+        /** displayCommands skipped because the daemon scope is unaffected. */
+        skippedDaemonCommands?: string[];
+    };
 };
 type MeshRefineStageStatus = 'passed' | 'failed' | 'skipped';
 type MeshRefinePatchEquivalenceSummary = {
@@ -277,6 +291,13 @@ export interface RefineContext {
     baseBranch: string;
     baseHead: string;
     branchHead: string;
+    /**
+     * Coarse daemon-vs-web change-impact for baseHead..branchHead, resolved in the
+     * resolve_refs stage and threaded into the validation gate to scope its command
+     * set. `undefined` means "could not classify" → the gate fails open and runs ALL
+     * commands (never skip on uncertainty).
+     */
+    changeImpact?: ChangedPackageClassification;
     validationSummary: Awaited<ReturnType<typeof runMeshRefineValidationGate>>;
     patchEquivalence: Awaited<ReturnType<typeof runMeshRefinePatchEquivalenceGate>>;
     submoduleReachability: Awaited<ReturnType<typeof runMeshRefineSubmoduleReachabilityGate>>;
@@ -424,5 +445,13 @@ export declare function runMeshRefineValidationGate(mesh: any, workspace: string
     persistedBootstrapState?: WorktreeBootstrapState | null;
     /** M2-2: called after an inherit-mode bootstrap run so the caller can persist the new state. */
     onBootstrapStateChange?: (state: WorktreeBootstrapState) => void;
+    /**
+     * Coarse daemon-vs-web change-impact for the branch (resolve_refs computes it
+     * over baseHead..branchHead). When provided and `isDaemonAffecting === false`,
+     * daemon-scoped validation commands are skipped (web + typecheck still run).
+     * When omitted or `isDaemonAffecting === true`, the full command set runs —
+     * fail-open to full validation on any uncertainty.
+     */
+    changeImpact?: ChangedPackageClassification;
 }): Promise<MeshRefineValidationSummary>;
 export {};

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.486",
+  "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.486",
-    "@adhdev/session-host-core": "0.9.82-rc.486",
+    "@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

@@ -17,6 +17,8 @@ import { handleMeshForwardEvent, queuePendingMeshCoordinatorEvent } from '../mes
 import { analyzeMeshRefineNodeChangeArea, orderMeshRefineBatchNodes } from '../mesh/mesh-refine-batch.js';
 import type { WorktreeBootstrapState } from '../mesh/worktree-bootstrap-config.js';
 import { DEFAULT_MESH_POLICY } from '../repo-mesh-types.js';
+import { classifyChangedPackages } from '../git/git-status.js';
+import type { ChangedPackageClassification } from '../git/git-status.js';
 import { readStringValue } from '../mesh/mesh-node-identity.js';
 import {
     alignRefinerySubmodulesAfterMerge,
@@ -80,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,
@@ -93,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,
@@ -120,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;
@@ -312,7 +372,24 @@ export async function refineResolveRefsStage(self: DaemonCommandRouter,
             const { stdout: branchHeadStdout } = await execFileAsync('git', ['rev-parse', branch], { cwd: node.workspace, encoding: 'utf8' });
             const baseHead = baseHeadRaw;
             const branchHead = branchHeadStdout.trim();
-            recordMeshRefineStage(refineStages, 'resolve_refs', 'passed', resolveStarted, { branch, baseBranch, baseHead, branchHead, ...(fetchWarning ? { fetchWarning } : {}) });
+
+            // Coarse daemon-vs-web change-impact for baseHead..branchHead, computed
+            // against the worktree so the same policy (.adhdev/change-impact.*) as the
+            // stale-build detector applies. Threaded onto ctx so the validation gate
+            // can scope its command set: a web-only branch skips daemon-scoped commands.
+            // FAIL-OPEN: any classification error leaves changeImpact undefined → the
+            // gate runs the full command set (never skip on uncertainty).
+            let changeImpact: ChangedPackageClassification | undefined;
+            try {
+                changeImpact = await classifyChangedPackages(node.workspace, baseHead, branchHead);
+            } catch {
+                changeImpact = undefined;
+            }
+            recordMeshRefineStage(refineStages, 'resolve_refs', 'passed', resolveStarted, {
+                branch, baseBranch, baseHead, branchHead,
+                ...(changeImpact ? { changeImpact } : {}),
+                ...(fetchWarning ? { fetchWarning } : {}),
+            });
 
             return {
                 kind: 'continue',
@@ -330,6 +407,7 @@ export async function refineResolveRefsStage(self: DaemonCommandRouter,
                     baseBranch,
                     baseHead,
                     branchHead,
+                    changeImpact,
                     validationSummary: undefined as any,
                     patchEquivalence: undefined as any,
                     submoduleReachability: undefined as any,
@@ -346,6 +424,9 @@ export async function refineValidationStage(self: DaemonCommandRouter, ctx: Refi
             const { mesh, node, branch, baseBranch, refineStages } = ctx;
             const validationStarted = Date.now();
             const validationSummary = await runMeshRefineValidationGate(mesh, node.workspace, {
+                // (a) Scope the validation command set by coarse change-impact (resolved
+                // in resolve_refs). Undefined → gate runs the full command set (fail-open).
+                changeImpact: ctx.changeImpact,
                 // M2-2: consume the node's persisted bootstrap state; persist re-runs.
                 persistedBootstrapState: (node as any).worktreeBootstrap as WorktreeBootstrapState | undefined,
                 onBootstrapStateChange: (state) => {
@@ -369,7 +450,9 @@ export async function refineValidationStage(self: DaemonCommandRouter, ctx: Refi
                     : undefined;
                 const buildValidationFailedError = (): string => {
                     const base = validationSummary.failureCode === 'missing_dependencies'
-                        ? 'Refinery validation dependencies are missing; merge/refine was not attempted. Configure validation.bootstrapCommands if Refinery should bootstrap dependencies before validation.'
+                        ? 'Refinery validation dependencies are missing for a change-affected package; merge/refine was not attempted. '
+                            + 'To make this self-service, either (1) configure .adhdev/worktree_bootstrap.json (or validation.bootstrapCommands in .adhdev/refine.json) so Refinery installs deps before validation, '
+                            + 'or (2) converge the branch via the documented manual fast-forward-only bypass (rebase onto the fetched base, verify strict ancestry, then push ff-only) instead of the refine gate.'
                         : validationSummary.failureCode === 'dependency_bootstrap_failed'
                             ? 'Refinery dependency/bootstrap command failed; merge/refine was not attempted.'
                             : validationSummary.failureCode === 'spawn_resolution_failed'

package/src/git/git-status.ts

@@ -438,6 +438,54 @@ function isNonRuntimeRootFile(file: string, policy: ResolvedChangeImpactPolicy):
   return false;
 }
 
+/** Coarse change-impact verdict produced from a changed-file list. */
+export interface ChangedPackageClassification {
+  isDaemonAffecting: boolean;
+  affectedPackages: string[];
+}
+
+/**
+ * Pure bucketer: classify an already-collected changed-file list into the coarse
+ * daemon-vs-web verdict, per the resolved policy. Shared by classifyDaemonBuildChange
+ * (buildCommit..HEAD) and classifyChangedPackages (arbitrary ref range) so the
+ * daemon/web boundary logic lives in exactly one place. An empty list stays
+ * conservative (daemon-affecting) so an actionable warning is never suppressed.
+ */
+function classifyChangedFileList(
+  files: string[],
+  policy: ResolvedChangeImpactPolicy,
+): ChangedPackageClassification {
+  if (files.length === 0) {
+    // No file diff (e.g. only merge metadata) — nothing actionable, but stay
+    // conservative and treat as daemon-affecting so we don't suppress a real warning.
+    return { isDaemonAffecting: true, affectedPackages: [] };
+  }
+  const pkgs = new Set<string>();
+  // A non-package path that is NOT a recognized benign root file (marker/doc).
+  // Only these force daemon-affecting; benign markers/docs are ignored so a
+  // gitlink-moving root commit over a marker-only oss commit no longer over-warns.
+  let sawRuntimeAmbiguousNonPackage = false;
+  for (const file of files) {
+    const match = file.match(/(?:^|\/)packages\/([^/]+)\//);
+    if (!match) {
+      if (!isNonRuntimeRootFile(file, policy)) sawRuntimeAmbiguousNonPackage = true;
+      continue;
+    }
+    pkgs.add(match[1]);
+  }
+  const affectedPackages = [...pkgs].sort();
+  // Daemon-affecting if: any runtime-ambiguous non-package file changed, any
+  // unknown package changed, or any explicit daemon-runtime package changed.
+  // The daemon is unaffected only when every changed file is either a known
+  // web-only package or a recognized benign root file (and at least one such
+  // file changed) — i.e. nothing runtime-ambiguous remains. Unlisted/new packages
+  // therefore stay daemon-affecting (fail-safe default preserved).
+  const allBenign =
+    !sawRuntimeAmbiguousNonPackage &&
+    affectedPackages.every((p) => policy.webOnlyPackages.has(p) && !policy.daemonRuntimePackages.has(p));
+  return { isDaemonAffecting: !allBenign, affectedPackages };
+}
+
 /**
  * Determine whether the changes between buildCommit..HEAD touch any daemon-runtime
  * package, per the resolved policy. Returns isDaemonAffecting:true conservatively
@@ -449,47 +497,54 @@ async function classifyDaemonBuildChange(
   buildCommit: string,
   options: GitStatusOptions,
   policy: ResolvedChangeImpactPolicy,
-): Promise<{ isDaemonAffecting: boolean; affectedPackages: string[] }> {
+): Promise<ChangedPackageClassification> {
   try {
     const diff = await runGit(repoPath, ['diff', '--name-only', `${buildCommit}..HEAD`], options);
     const files = diff.stdout
       .split('\n')
       .map((line) => line.trim())
       .filter(Boolean);
-    if (files.length === 0) {
-      // No file diff (e.g. only merge metadata) — nothing actionable, but stay
-      // conservative and treat as daemon-affecting so we don't suppress a real warning.
-      return { isDaemonAffecting: true, affectedPackages: [] };
-    }
-    const pkgs = new Set<string>();
-    // A non-package path that is NOT a recognized benign root file (marker/doc).
-    // Only these force daemon-affecting; benign markers/docs are ignored so a
-    // gitlink-moving root commit over a marker-only oss commit no longer over-warns.
-    let sawRuntimeAmbiguousNonPackage = false;
-    for (const file of files) {
-      const match = file.match(/(?:^|\/)packages\/([^/]+)\//);
-      if (!match) {
-        if (!isNonRuntimeRootFile(file, policy)) sawRuntimeAmbiguousNonPackage = true;
-        continue;
-      }
-      pkgs.add(match[1]);
-    }
-    const affectedPackages = [...pkgs].sort();
-    // Daemon-affecting if: any runtime-ambiguous non-package file changed, any
-    // unknown package changed, or any explicit daemon-runtime package changed.
-    // The daemon is unaffected only when every changed file is either a known
-    // web-only package or a recognized benign root file (and at least one such
-    // file changed) — i.e. nothing runtime-ambiguous remains.
-    const allBenign =
-      !sawRuntimeAmbiguousNonPackage &&
-      affectedPackages.every((p) => policy.webOnlyPackages.has(p) && !policy.daemonRuntimePackages.has(p));
-    return { isDaemonAffecting: !allBenign, affectedPackages };
+    return classifyChangedFileList(files, policy);
   } catch {
     // diff probe failed → can't prove web-only; stay conservative.
     return { isDaemonAffecting: true, affectedPackages: [] };
   }
 }
 
+/**
+ * Ref-parameterized change-impact classification for a repo/worktree, reusing the
+ * exact daemon-vs-web bucketing that the stale-build detector uses — but over an
+ * arbitrary `fromRef..toRef` range (e.g. a refine base head → branch head) instead
+ * of the live daemon's build commit → HEAD, and WITHOUT any daemonBuildInfo caching.
+ *
+ * Policy is resolved the same way as getGitRepoStatus: an explicit
+ * `options.changeImpactConfig` wins; otherwise the repo's `.adhdev/change-impact.*`
+ * is auto-loaded; otherwise the built-in ADHDev default policy applies. The
+ * classification uses `git diff --name-only fromRef..toRef`.
+ *
+ * FAIL-OPEN on error: if the diff can't be collected (bad ref, not a repo), the
+ * caller should treat "no verdict" as "run everything" — so we throw rather than
+ * returning a misleading benign verdict. Callers wrap this in try/catch and leave
+ * changeImpact undefined on failure. Unclassified/new packages still default to
+ * isDaemonAffecting:true (never silently skipped).
+ */
+export async function classifyChangedPackages(
+  repoPath: string,
+  fromRef: string,
+  toRef: string,
+  options: GitStatusOptions = {},
+): Promise<ChangedPackageClassification> {
+  const repo = await resolveGitRepository(repoPath, options);
+  const { config } = resolveChangeImpactConfigForRepo(repo.repoRoot, options);
+  const policy = resolveChangeImpactPolicy(config);
+  const diff = await runGit(repoPath, ['diff', '--name-only', `${fromRef}..${toRef}`], options);
+  const files = diff.stdout
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+  return classifyChangedFileList(files, policy);
+}
+
 /**
  * Resolve the Change Impact config to apply for this status read. Priority:
  *   - options.changeImpactConfig === null → force built-in default policy (no load).

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) } : {}),
             },