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

package/dist/commands/router-refine.d.ts

@@ -13,6 +13,20 @@ export declare function buildRefineJobHandle(self: DaemonCommandRouter, args: {
     retryOfJobId?: string;
     coordinatorDaemonId?: string;
 }): MeshRefineJobHandle;
+/**
+ * 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 declare function slimRefineEventResult(result: Record<string, unknown>): Record<string, unknown>;
 export declare function queueRefineJobEvent(self: DaemonCommandRouter, event: 'refine:accepted' | 'refine:completed' | 'refine:failed', handle: MeshRefineJobHandle, result?: Record<string, unknown>): void;
 export declare function appendRefineJobLedger(self: DaemonCommandRouter, kind: 'task_dispatched' | 'task_completed' | 'task_failed', handle: MeshRefineJobHandle, result?: Record<string, unknown>): Promise<void>;
 /**

package/dist/git/git-status.d.ts

@@ -67,6 +67,29 @@ export interface GitStatusOptions {
  */
 export declare const GIT_FETCH_THROTTLE_MS = 30000;
 export declare function getGitRepoStatus(workspace: string, options?: GitStatusOptions): Promise<GitRepoStatus>;
+/** Coarse change-impact verdict produced from a changed-file list. */
+export interface ChangedPackageClassification {
+    isDaemonAffecting: boolean;
+    affectedPackages: string[];
+}
+/**
+ * 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 declare function classifyChangedPackages(repoPath: string, fromRef: string, toRef: string, options?: GitStatusOptions): Promise<ChangedPackageClassification>;
 interface ParsedPorcelainStatus {
     branch: string | null;
     /** Full HEAD object id from `# branch.oid`, or null when detached/unborn. */

package/dist/index.js

@@ -414,10 +414,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "cae0f42043ded25e4d3bed93d9f658035c09e007" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "cae0f420" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.486" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-09T23:19:53.642Z" : void 0);
+  const commit = readInjected(true ? "a659fcbbe9641240de42b95804a16b8852c5b4eb" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "a659fcbb" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.488" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-10T03:46:52.780Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -789,30 +789,41 @@ function isNonRuntimeRootFile(file, policy) {
   }
   return false;
 }
+function classifyChangedFileList(files, policy) {
+  if (files.length === 0) {
+    return { isDaemonAffecting: true, affectedPackages: [] };
+  }
+  const pkgs = /* @__PURE__ */ new Set();
+  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();
+  const allBenign = !sawRuntimeAmbiguousNonPackage && affectedPackages.every((p) => policy.webOnlyPackages.has(p) && !policy.daemonRuntimePackages.has(p));
+  return { isDaemonAffecting: !allBenign, affectedPackages };
+}
 async function classifyDaemonBuildChange(repoPath, buildCommit, options, policy) {
   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) {
-      return { isDaemonAffecting: true, affectedPackages: [] };
-    }
-    const pkgs = /* @__PURE__ */ new Set();
-    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();
-    const allBenign = !sawRuntimeAmbiguousNonPackage && affectedPackages.every((p) => policy.webOnlyPackages.has(p) && !policy.daemonRuntimePackages.has(p));
-    return { isDaemonAffecting: !allBenign, affectedPackages };
+    return classifyChangedFileList(files, policy);
   } catch {
     return { isDaemonAffecting: true, affectedPackages: [] };
   }
 }
+async function classifyChangedPackages(repoPath, fromRef, toRef, options = {}) {
+  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);
+}
 function resolveChangeImpactConfigForRepo(repoRoot, options) {
   if (options.changeImpactConfig === null) {
     return { config: null, sourceKey: "forced-default" };
@@ -6164,6 +6175,7 @@ function reclaimStrandedAssignedTask(meshId, taskId, opts) {
     delete entry.assignedSessionId;
     delete entry.assignedProviderType;
     delete entry.dispatchTimestamp;
+    entry.dispatchNonce = (entry.dispatchNonce || 0) + 1;
     entry.strandedReclaimCount = reclaims;
     entry.updatedAt = now;
     endTaskDispatchInFlight(meshId, taskId);
@@ -7188,6 +7200,7 @@ var init_mesh_runtime_store = __esm({
           entry.assignedSessionId = sessionId;
           if (providerType) entry.assignedProviderType = providerType;
           entry.dispatchTimestamp = now;
+          entry.dispatchNonce = (entry.dispatchNonce || 0) + 1;
           entry.updatedAt = now;
           this.db.prepare(`
                 UPDATE mesh_queue SET
@@ -15646,6 +15659,10 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
             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 } : {}
           }
@@ -15704,6 +15721,8 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
         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() } : {},
         ...readNonEmptyString2(task.sourceCoordinatorSessionId) ? { coordinatorSessionId: readNonEmptyString2(task.sourceCoordinatorSessionId) } : {}
       }
@@ -19687,6 +19706,42 @@ function sourceWorkerAutoApproves(components, sessionId) {
     return false;
   }
 }
+function stopStaleMeshWorker(components, args) {
+  const { meshId, sessionId, providerType } = args;
+  const stopArgs = {
+    targetSessionId: sessionId,
+    ...providerType ? { cliType: providerType } : {},
+    mode: "hard",
+    reason: "stale_mesh_dispatch_reclaimed"
+  };
+  try {
+    const isLocal = components.cliManager?.adapters?.has?.(sessionId) === true;
+    if (isLocal) {
+      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) => LOG.warn("MeshQueue", `Local stop of stale worker ${sessionId} failed: ${e?.message || e}`));
+      return;
+    }
+    let daemonId = args.daemonId;
+    if (!daemonId && args.nodeId) {
+      try {
+        const mesh = getMeshWithCache(components, meshId);
+        const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, args.nodeId));
+        daemonId = node ? readMeshNodeDaemonId(node) || void 0 : void 0;
+      } catch {
+      }
+    }
+    if (daemonId && components.dispatchMeshCommand) {
+      Promise.resolve(components.dispatchMeshCommand(daemonId, "stop_cli", stopArgs)).catch((e) => 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 \u2014 task will re-strand-and-fail if the worker completes.`);
+    }
+  } catch (e) {
+    LOG.warn("MeshQueue", `stopStaleMeshWorker error for ${sessionId}: ${e?.message || e}`);
+  }
+}
 function injectMeshSystemMessage(components, args) {
   const eventSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
   const eventNodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
@@ -19926,6 +19981,35 @@ function injectMeshSystemMessage(components, args) {
     }
     if (sessionId) {
       const startedTaskId = readNonEmptyString2(args.metadataEvent.taskId) || void 0;
+      const startedNonce = typeof args.metadataEvent.dispatchNonce === "number" ? args.metadataEvent.dispatchNonce : void 0;
+      if (startedTaskId && startedNonce !== void 0) {
+        const currentRow = (() => {
+          try {
+            return MeshRuntimeStore.getInstance().findQueueEntryById(args.meshId, startedTaskId);
+          } catch {
+            return null;
+          }
+        })();
+        const currentNonce = typeof currentRow?.dispatchNonce === "number" ? currentRow.dispatchNonce : void 0;
+        if (currentNonce !== void 0 && startedNonce < currentNonce) {
+          LOG.warn("MeshQueue", `Rejecting stale mesh dispatch: task ${startedTaskId} generating_started from session ${sessionId} (node ${nodeId ?? "?"}) carries dispatchNonce ${startedNonce} < current ${currentNonce} \u2014 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: readNonEmptyString2(args.metadataEvent.providerType) || readNonEmptyString2(args.metadataEvent.cliType),
+            daemonId: readNonEmptyString2(args.metadataEvent.sourceDaemonId) || readNonEmptyString2(args.metadataEvent.daemonId)
+          });
+          return { success: true, forwarded: 0, suppressed: true, staleDispatchRejected: true };
+        }
+      }
       if (startedTaskId) {
         updateDirectDispatchStatus(args.meshId, sessionId, "acked", startedTaskId);
       } else if (sessionHasActiveAssignment(args.meshId, sessionId)) {
@@ -20462,6 +20546,7 @@ var init_mesh_event_forwarding = __esm({
     init_dist();
     init_mesh_events_stale();
     init_mesh_task_inflight();
+    init_mesh_node_identity();
     init_mesh_events_utils();
     init_mesh_event_classify();
     init_mesh_queue_assignment();
@@ -45966,6 +46051,10 @@ var CliProviderInstance = class _CliProviderInstance {
       // 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.
@@ -46001,15 +46090,17 @@ var CliProviderInstance = class _CliProviderInstance {
     if (!this.settings.meshNodeFor && !this.settings.meshActiveTaskId && !this.settings.meshNodeId) return;
     if (this.settings.launchedByCoordinator === true) {
       if (!this.settings.meshActiveTaskId) return;
-      const { meshActiveTaskId: meshActiveTaskId2, ...rest2 } = this.settings;
+      const { meshActiveTaskId: meshActiveTaskId2, meshActiveDispatchNonce: meshActiveDispatchNonce2, ...rest2 } = this.settings;
       void meshActiveTaskId2;
+      void meshActiveDispatchNonce2;
       this.settings = rest2;
       this.adapter.updateRuntimeSettings?.(this.settings);
       return;
     }
-    const { meshNodeFor, meshNodeId, meshActiveTaskId, ...rest } = this.settings;
+    const { meshNodeFor, meshNodeId, meshActiveTaskId, meshActiveDispatchNonce, ...rest } = this.settings;
     void meshNodeFor;
     void meshActiveTaskId;
+    void meshActiveDispatchNonce;
     const lastNodeId = typeof meshNodeId === "string" && meshNodeId.trim() ? meshNodeId.trim() : typeof rest.meshLastNodeId === "string" && rest.meshLastNodeId.trim() ? rest.meshLastNodeId.trim() : void 0;
     this.settings = lastNodeId ? { ...rest, meshLastNodeId: lastNodeId } : rest;
     this.adapter.updateRuntimeSettings?.(this.settings);
@@ -47498,6 +47589,9 @@ var CliProviderInstance = class _CliProviderInstance {
         const resolved = this.completingTurnTaskId();
         if (resolved) enrichedEvent.taskId = resolved;
       }
+      if (enrichedEvent.dispatchNonce === void 0 && typeof this.settings.meshActiveDispatchNonce === "number") {
+        enrichedEvent.dispatchNonce = this.settings.meshActiveDispatchNonce;
+      }
     }
     if (this.context?.emitProviderEvent) {
       this.context.emitProviderEvent(enrichedEvent);
@@ -50384,6 +50478,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 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 {
@@ -58219,6 +58317,7 @@ function orderMeshRefineBatchNodes(changeAreas) {
 
 // src/commands/router-refine.ts
 init_repo_mesh_types();
+init_git_status();
 init_mesh_node_identity();
 
 // src/mesh/mesh-refine-gates.ts
@@ -59159,6 +59258,41 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
     if (fs31.existsSync((0, import_path14.join)(cwd, "node_modules"))) return false;
     return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs31.existsSync((0, import_path14.join)(cwd, lock)));
   };
+  const needsNodeModules = (candidate, cwd) => isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd);
+  const isDaemonScopedCommand = (candidate) => {
+    const haystack = [candidate.command, ...candidate.args || [], candidate.displayCommand || ""].join(" ").toLowerCase();
+    if (candidate.category === "typecheck") return false;
+    if (/\btypecheck\b/.test(haystack)) return false;
+    if (/\bweb-core\b|\bweb-cloud\b|\bweb-standalone\b|\btest:web\b/.test(haystack)) return false;
+    return /\bdaemon-core\b|\bdaemon-cloud\b|\btest:daemon\b|check-vendor-drift/.test(haystack);
+  };
+  const scopeUnaffectedDaemon = opts?.changeImpact?.isDaemonAffecting === false;
+  const skippedDaemonCommands = [];
+  const commandsToRun = [];
+  for (const candidate of selection.commands) {
+    if (scopeUnaffectedDaemon && isDaemonScopedCommand(candidate)) {
+      skippedDaemonCommands.push(candidate.displayCommand);
+      summary.commandsRun.push({
+        command: candidate.command,
+        args: candidate.args,
+        displayCommand: candidate.displayCommand,
+        category: candidate.category,
+        source: candidate.source,
+        passed: true,
+        skipped: true,
+        skipReason: "unaffected_daemon_scope"
+      });
+      continue;
+    }
+    commandsToRun.push(candidate);
+  }
+  if (opts?.changeImpact) {
+    summary.changeImpact = {
+      isDaemonAffecting: opts.changeImpact.isDaemonAffecting,
+      affectedPackages: opts.changeImpact.affectedPackages,
+      ...skippedDaemonCommands.length ? { skippedDaemonCommands } : {}
+    };
+  }
   if (runLegacyBootstrapCommands) {
     summary.bootstrap = { stage: "legacy" };
     for (const candidate of selection.bootstrapCommands) {
@@ -59193,23 +59327,22 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
       }
     }
   }
-  for (const candidate of selection.commands) {
+  let missingDepsBlocked = false;
+  for (const candidate of commandsToRun) {
     const startedAt = Date.now();
     const cwd = candidate.cwd ? (0, import_path14.resolve)(workspace, candidate.cwd) : workspace;
     const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
     const bootstrapProvidedDependencies = summary.bootstrap?.stage === "cached" || summary.bootstrap?.stage === "ran" || summary.bootstrap?.stage === "legacy";
-    if (!bootstrapProvidedDependencies && isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd)) {
+    if (!bootstrapProvidedDependencies && needsNodeModules(candidate, cwd)) {
       summary.commandsRun.push(commandRecord(candidate, cwd, startedAt, {
-        stderr: "Dependencies appear to be missing: package.json and a lockfile are present, but node_modules is absent. Configure validation.bootstrapCommands in repo mesh/refine config if Refinery should install/bootstrap before validation."
+        stderr: "Dependencies appear to be missing: package.json and a lockfile are present, but node_modules is absent. Configure validation.bootstrapCommands (or .adhdev/worktree_bootstrap.json) in repo mesh/refine config if Refinery should install/bootstrap before validation."
       }, false, {
         exitCode: null,
         skipped: true,
         failureKind: "missing_dependencies"
       }));
-      summary.status = "failed";
-      summary.failureKind = "missing_dependencies";
-      summary.failureCode = "missing_dependencies";
-      return summary;
+      missingDepsBlocked = true;
+      continue;
     }
     const resolvedCommand = resolveWin32Executable(candidate.command);
     const spawn5 = buildWin32ExecFileSpawn(resolvedCommand, candidate.args);
@@ -59245,6 +59378,12 @@ async function runMeshRefineValidationGate(mesh, workspace, opts) {
       return summary;
     }
   }
+  if (missingDepsBlocked) {
+    summary.status = "failed";
+    summary.failureKind = "missing_dependencies";
+    summary.failureCode = "missing_dependencies";
+    return summary;
+  }
   summary.status = "passed";
   return summary;
 }
@@ -59277,7 +59416,50 @@ function buildRefineJobHandle(self, args) {
     }
   };
 }
+function slimRefineEventResult(result) {
+  const slim = {};
+  for (const key2 of [
+    "success",
+    "code",
+    "error",
+    "convergenceStatus",
+    "blockedReason",
+    "branch",
+    "into",
+    "terminalKind",
+    "nextStep",
+    "finalBranchConvergenceState"
+  ]) {
+    if (result[key2] !== void 0) slim[key2] = result[key2];
+  }
+  if (Array.isArray(result.unreachableSubmoduleCommits)) {
+    slim.unreachableSubmoduleCommits = result.unreachableSubmoduleCommits.map((e) => ({ path: e?.path, autoPublishAllowed: e?.autoPublishAllowed }));
+  }
+  if (result.validationSummary && typeof result.validationSummary === "object") {
+    const vs = result.validationSummary;
+    slim.validationSummary = {
+      status: vs.status,
+      failureCode: vs.failureCode,
+      configSource: vs.configSource,
+      configSourceType: vs.configSourceType,
+      commandsRunCount: Array.isArray(vs.commandsRun) ? vs.commandsRun.length : void 0
+    };
+  }
+  if (result.patchEquivalence && typeof result.patchEquivalence === "object") {
+    const pe = result.patchEquivalence;
+    slim.patchEquivalence = { status: pe.status, equivalent: pe.equivalent };
+  }
+  if (result.submoduleReachability && typeof result.submoduleReachability === "object") {
+    const sr = result.submoduleReachability;
+    slim.submoduleReachability = {
+      checked: Array.isArray(sr.entries) ? sr.entries.length : void 0,
+      unreachable: Array.isArray(sr.unreachable) ? sr.unreachable.length : void 0
+    };
+  }
+  return slim;
+}
 function queueRefineJobEvent(self, event, handle, result) {
+  const slimResult = result ? slimRefineEventResult(result) : void 0;
   const metadataEvent = {
     source: "refine_mesh_node_async_job",
     jobId: handle.jobId,
@@ -59290,7 +59472,7 @@ function queueRefineJobEvent(self, event, handle, result) {
     startedAt: handle.startedAt,
     completedAt: handle.completedAt,
     retryOfJobId: handle.retryOfJobId,
-    ...result ? { result } : {}
+    ...slimResult ? { result: slimResult } : {}
   };
   const eventPayload = {
     event,
@@ -59317,7 +59499,7 @@ function queueRefineJobEvent(self, event, handle, result) {
         startedAt: handle.startedAt,
         completedAt: handle.completedAt,
         retryOfJobId: handle.retryOfJobId,
-        ...result ? { result } : {}
+        ...slimResult ? { result: slimResult } : {}
       }
     );
     if (forwarded?.success === true) return;
@@ -59452,7 +59634,20 @@ async function refineResolveRefsStage(self, meshId, nodeId, args, refineStages)
   const { stdout: branchHeadStdout } = await execFileAsync4("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 } : {} });
+  let changeImpact;
+  try {
+    changeImpact = await classifyChangedPackages(node.workspace, baseHead, branchHead);
+  } catch {
+    changeImpact = void 0;
+  }
+  recordMeshRefineStage(refineStages, "resolve_refs", "passed", resolveStarted, {
+    branch,
+    baseBranch,
+    baseHead,
+    branchHead,
+    ...changeImpact ? { changeImpact } : {},
+    ...fetchWarning ? { fetchWarning } : {}
+  });
   return {
     kind: "continue",
     ctx: {
@@ -59469,6 +59664,7 @@ async function refineResolveRefsStage(self, meshId, nodeId, args, refineStages)
       baseBranch,
       baseHead,
       branchHead,
+      changeImpact,
       validationSummary: void 0,
       patchEquivalence: void 0,
       submoduleReachability: void 0
@@ -59479,6 +59675,9 @@ async function refineValidationStage(self, ctx) {
   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.worktreeBootstrap,
     onBootstrapStateChange: (state) => {
@@ -59498,7 +59697,7 @@ async function refineValidationStage(self, ctx) {
   if (validationSummary.status === "failed") {
     const firstFailedCmd = Array.isArray(validationSummary.commandsRun) ? validationSummary.commandsRun.find((c) => c.success === false) : void 0;
     const buildValidationFailedError = () => {
-      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." : validationSummary.failureCode === "dependency_bootstrap_failed" ? "Refinery dependency/bootstrap command failed; merge/refine was not attempted." : validationSummary.failureCode === "spawn_resolution_failed" ? validationSummary.spawnResolutionError || "Refinery validation command could not be spawned (executable not found); merge/refine was not attempted." : "Refinery validation gate failed; merge/refine was not attempted.";
+      const base = validationSummary.failureCode === "missing_dependencies" ? "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" ? validationSummary.spawnResolutionError || "Refinery validation command could not be spawned (executable not found); merge/refine was not attempted." : "Refinery validation gate failed; merge/refine was not attempted.";
       if (!firstFailedCmd) return base;
       const cmdName = typeof firstFailedCmd.displayCommand === "string" ? firstFailedCmd.displayCommand : typeof firstFailedCmd.command === "string" ? [firstFailedCmd.command, ...Array.isArray(firstFailedCmd.args) ? firstFailedCmd.args : []].join(" ").trim() : typeof firstFailedCmd.cmd === "string" ? firstFailedCmd.cmd : "";
       const rawOutput = [firstFailedCmd.stdout, firstFailedCmd.stderr, firstFailedCmd.output].filter((s2) => typeof s2 === "string" && s2.length > 0).join("\n");