@adhdev/daemon-standalone 1.0.48 → 1.0.49-rc.10

package/dist/index.js

@@ -37056,10 +37056,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "c19180c49771cb79932c9bf67d368436d94dbc34" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "c19180c4" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.48" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-14T01:59:31.058Z" : void 0);
+      const commit = readInjected(true ? "85491e20f327dc51eb20e6b0674af0041e0c5f5e" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "85491e20" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.49-rc.10" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-14T23:22:28.218Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -38307,7 +38307,7 @@ var require_dist3 = __commonJS({
       }
     });
     function resolveBuildTrack(env2 = process.env) {
-      const injected = true ? "stable" : void 0;
+      const injected = true ? "preview" : void 0;
       const stamped = typeof injected === "string" ? injected.trim() : "";
       const raw = (stamped || (env2[BUILD_CHANNEL_ENV_VAR] ?? "").trim()).toLowerCase();
       return raw === "preview" || raw === "next" ? "preview" : "stable";
@@ -42270,6 +42270,8 @@ ${error48.message || ""}`;
       interpolateArgs: () => interpolateArgs,
       interpolateString: () => interpolateString,
       isMeshTaskDifficulty: () => isMeshTaskDifficulty,
+      isPhantomDaemonEntry: () => isPhantomDaemonEntry,
+      isRawDaemonDoId: () => isRawDaemonDoId,
       joinRepoPath: () => joinRepoPath,
       machineCoreFromDaemonId: () => machineCoreFromDaemonId,
       meshNodeIdMatches: () => meshNodeIdMatches,
@@ -42565,6 +42567,18 @@ ${error48.message || ""}`;
       if (!left || !right) return false;
       return left === right;
     }
+    function isRawDaemonDoId(id) {
+      const trimmed = readString2(id);
+      return !!trimmed && /^[0-9a-f]{64}$/i.test(trimmed);
+    }
+    function isPhantomDaemonEntry(entry) {
+      if (!entry) return false;
+      if (!isRawDaemonDoId(entry.id)) return false;
+      const hasMachineEvidence = Boolean(
+        readString2(entry.machineNickname) || readString2(entry.nickname) || readString2(entry.hostname) || readString2(entry.platform) || readString2(entry.machine?.hostname) || readString2(entry.machine?.platform) || readString2(entry.machineId) || Array.isArray(entry.sessions) && entry.sessions.length > 0
+      );
+      return !hasMachineEvidence;
+    }
     function machineCoreFromDaemonId(id) {
       const trimmed = readString2(id);
       if (!trimmed) return void 0;
@@ -42990,7 +43004,9 @@ ${error48.message || ""}`;
           "mesh_magi_kind_panel_list",
           "mesh_node_slots_set",
           "mesh_node_slots_list",
-          "mesh_node_slots_propose"
+          "mesh_node_slots_propose",
+          "mesh_coordinator_prompt_append_get",
+          "mesh_coordinator_prompt_append_set"
         ];
         CANONICAL_MESH_TOOL_COUNT = CANONICAL_MESH_TOOL_NAMES.length;
         STATUS_PROBE_ARG_KEY = "_statusProbe";
@@ -52711,7 +52727,9 @@ When you compose the task message you dispatch to a node, include this requireme
 | \`mesh_magi_kind_panel_list\` | List configured task_kind \u2192 MAGI kind-panel slot bindings (machine-local, read-only) |
 | \`mesh_node_slots_list\` | List a node's capability slots (its AI-tool profile: provider/model/thinking + difficulty range + capability tags), read-only |
 | \`mesh_node_slots_set\` | PROPOSE (dry-run) or APPLY a node's capability slots \u2014 how you autonomously retune a node's tool profile; WHOLESALE replacement, present current-vs-proposed and get user approval before write=true |
-| \`mesh_node_slots_propose\` | AUTO-DETECT a node's installed CLI agents and DRAFT a slot profile from them (read-only, never writes) \u2014 use when a node has no slots yet or new CLIs were installed; reports droppedSlots (what a wholesale write would destroy), then apply via mesh_node_slots_set write=true after approval |`;
+| \`mesh_node_slots_propose\` | AUTO-DETECT a node's installed CLI agents and DRAFT a slot profile from them (read-only, never writes) \u2014 use when a node has no slots yet or new CLIs were installed; reports droppedSlots (what a wholesale write would destroy), then apply via mesh_node_slots_set write=true after approval |
+| \`mesh_coordinator_prompt_append_get\` | Read this daemon's user-level coordinator prompt APPEND text for a CLI type (per-machine file, applies to every mesh this daemon coordinates) |
+| \`mesh_coordinator_prompt_append_set\` | Write or clear this daemon's user-level coordinator prompt APPEND text for a CLI type \u2014 APPEND ONLY, always stacks after the base prompt; there is no tool to replace the base prompt itself |`;
         TOOL_EXPOSURE_PREFLIGHT_SECTION = `## Tool Exposure Preflight
 
 Before doing any coordinator work, confirm that the actual callable tool list includes \`mesh_status\` and the other \`mesh_*\` tools from the table above. If this Repo Mesh coordinator prompt is present but the callable \`mesh_*\` tools are missing, the MCP server/tool manifest is stale or not injected yet. Do not substitute terminal/file/git tools, do not inspect or edit the repository directly, and do not continue as a non-mesh local coding agent. Stop immediately and tell the user to run \`/reload-mcp\` or start a fresh coordinator session so ADHDev can reconnect \`adhdev-mesh\`.`;
@@ -55440,6 +55458,8 @@ ${rendered}`, "utf-8");
     });
     function readProviderPriorityFromPolicy(policy) {
       const record2 = policy && typeof policy === "object" && !Array.isArray(policy) ? policy : {};
+      const derived = deriveProviderPriorityFromSlots(record2.slots);
+      if (derived.length) return derived;
       const raw = record2.providerPriority;
       if (Array.isArray(raw)) {
         const seen = /* @__PURE__ */ new Set();
@@ -55450,7 +55470,7 @@ ${rendered}`, "utf-8");
         });
         if (explicit.length) return explicit;
       }
-      return deriveProviderPriorityFromSlots(record2.slots);
+      return [];
     }
     function normalizeProviderRoles(value) {
       if (!Array.isArray(value)) return [];
@@ -55532,7 +55552,7 @@ ${rendered}`, "utf-8");
       const workspace = readStringValue(node.workspace, node.repoRoot, node.repo_root);
       const workspaceName = workspace ? workingDirBasename(workspace) : void 0;
       const host = readStringValue(node.machineName, node.machine_name, node.hostname, node.host, node.daemonId, node.daemon_id, node.machineId, node.machine_id);
-      const provider = providerPriority[0] || (Array.isArray(node.providers) ? readStringValue(...node.providers) : void 0);
+      const provider = readProviderPriorityFromPolicy(node.policy)[0] || providerPriority[0] || (Array.isArray(node.providers) ? readStringValue(...node.providers) : void 0);
       const parts = [workspaceName, host, provider].filter(Boolean);
       if (parts.length > 0) return parts.join(" \xB7 ");
       return nodeId || "unidentified mesh node";
@@ -57708,7 +57728,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_mesh_work_queue();
       }
     });
-    function quotaEntryFor(node, providerType) {
+    function directQuotaEntryFor(node, providerType) {
       const facts = node?.nodeFacts;
       if (!facts || typeof facts !== "object") return null;
       const reportedAt = Number(facts.reportedAt);
@@ -57717,6 +57737,14 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       if (!quota || typeof quota !== "object") return null;
       return { facts: { reportedAt }, quota };
     }
+    function quotaEntryFor(node, providerType, context) {
+      const direct = directQuotaEntryFor(node, providerType);
+      if (direct) return direct;
+      const sourceNodeId = typeof node?.clonedFromNodeId === "string" ? node.clonedFromNodeId.trim() : "";
+      if (!sourceNodeId || !Array.isArray(context?.nodes)) return null;
+      const sourceNode = context.nodes.find((candidate) => candidate !== node && meshNodeIdMatches(candidate, sourceNodeId));
+      return sourceNode ? directQuotaEntryFor(sourceNode, providerType) : null;
+    }
     function quotaSnapshotAgeMs(facts, quota, now = Date.now()) {
       const updatedAt = Number(quota.updatedAt);
       if (!Number.isFinite(updatedAt) || updatedAt <= 0) return Number.POSITIVE_INFINITY;
@@ -57739,10 +57767,23 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const reporterNowMs = Number(quota.updatedAt) + ageMs2;
       return resetsAt - reporterNowMs < imminentMs;
     }
-    function evaluateProviderQuotaGate(node, providerType, policy, now = Date.now()) {
-      const entry = quotaEntryFor(node, providerType);
+    function isRetainedWindowTrustworthy(window, facts, quota, policy, now) {
+      const resetsAt = Number(window?.resetsAt);
+      if (!Number.isFinite(resetsAt) || resetsAt <= 0) {
+        return isQuotaSnapshotFresh(facts, quota, policy, now);
+      }
+      const ageMs2 = quotaSnapshotAgeMs(facts, quota, now);
+      if (!Number.isFinite(ageMs2)) return false;
+      const reporterNowMs = Number(quota.updatedAt) + ageMs2;
+      if (!Number.isFinite(reporterNowMs)) return false;
+      return resetsAt > reporterNowMs;
+    }
+    function evaluateProviderQuotaGate(node, providerType, policy, now = Date.now(), context) {
+      const entry = quotaEntryFor(node, providerType, context);
       if (!entry) return null;
       const { facts, quota } = entry;
+      let sessionTrustworthy = true;
+      let weeklyTrustworthy = true;
       if (quota.status !== "ok") {
         if (quota.status === "error" && quota.metadata?.failureKind === "quota-exhausted" && isQuotaSnapshotFresh(facts, quota, policy, now)) {
           return {
@@ -57752,12 +57793,15 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
             thresholdPercent: 0
           };
         }
+        if (quota.metadata?.lastGoodWindows !== true) return null;
+        sessionTrustworthy = isRetainedWindowTrustworthy(quota.session, facts, quota, policy, now);
+        weeklyTrustworthy = isRetainedWindowTrustworthy(quota.weekly, facts, quota, policy, now);
+      } else if (!isQuotaSnapshotFresh(facts, quota, policy, now)) {
         return null;
       }
-      if (!isQuotaSnapshotFresh(facts, quota, policy, now)) return null;
       const resolved = resolveQuotaRoutingPolicy(policy);
       const session = remainingPercent(quota.session);
-      if (session !== void 0 && session < resolved.sessionMinRemainingPercent && !isSessionResetImminent(quota.session, facts, quota, resolved.sessionResetImminentMs, now)) {
+      if (sessionTrustworthy && session !== void 0 && session < resolved.sessionMinRemainingPercent && !isSessionResetImminent(quota.session, facts, quota, resolved.sessionResetImminentMs, now)) {
         return {
           reason: PROVIDER_QUOTA_SESSION_LOW_SKIP_REASON,
           window: "session",
@@ -57766,7 +57810,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         };
       }
       const weekly = remainingPercent(quota.weekly);
-      if (weekly !== void 0 && weekly < resolved.weeklyMinRemainingPercent) {
+      if (weeklyTrustworthy && weekly !== void 0 && weekly < resolved.weeklyMinRemainingPercent) {
         return {
           reason: PROVIDER_QUOTA_WEEKLY_LOW_SKIP_REASON,
           window: "weekly",
@@ -57776,8 +57820,8 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       return null;
     }
-    function expiryRiskForRanking(node, providerType, axis, policy, now = Date.now()) {
-      const entry = quotaEntryFor(node, providerType);
+    function expiryRiskForRanking(node, providerType, axis, policy, now = Date.now(), context) {
+      const entry = quotaEntryFor(node, providerType, context);
       if (!entry) return void 0;
       const { facts, quota } = entry;
       if (quota.status !== "ok") return void 0;
@@ -57796,19 +57840,19 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const elapsedFraction = Math.min(1, Math.max(0, 1 - (resetsAt - reporterNowMs) / windowMs));
       return { remainingPercent: remaining, risk: remaining * elapsedFraction };
     }
-    function rankProvidersByQuotaGate(node, orderedProviderTypes, policy, now = Date.now()) {
+    function rankProvidersByQuotaGate(node, orderedProviderTypes, policy, now = Date.now(), context) {
       const clear = [];
       const gated = [];
       for (const providerType of orderedProviderTypes) {
-        const block2 = evaluateProviderQuotaGate(node, providerType, policy, now);
+        const block2 = evaluateProviderQuotaGate(node, providerType, policy, now, context);
         if (block2) gated.push({ providerType, block: block2 });
         else clear.push(providerType);
       }
-      const weeklyByProvider = new Map(clear.map((p) => [p, expiryRiskForRanking(node, p, "weekly", policy, now)]));
+      const weeklyByProvider = new Map(clear.map((p) => [p, expiryRiskForRanking(node, p, "weekly", policy, now, context)]));
       const headroomPercent = resolveQuotaRoutingPolicy(policy).sessionAxisWeeklyHeadroomPercent;
       const weeklyMeasured = [...weeklyByProvider.values()].filter((w) => w !== void 0);
       const sessionAxisActive = weeklyMeasured.length > 0 && weeklyMeasured.every((w) => w.remainingPercent > headroomPercent);
-      const sessionByProvider = sessionAxisActive ? new Map(clear.map((p) => [p, expiryRiskForRanking(node, p, "session", policy, now)])) : void 0;
+      const sessionByProvider = sessionAxisActive ? new Map(clear.map((p) => [p, expiryRiskForRanking(node, p, "session", policy, now, context)])) : void 0;
       clear.sort((a, b) => {
         const wa = weeklyByProvider.get(a);
         const wb = weeklyByProvider.get(b);
@@ -57831,13 +57875,13 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       });
       return { clear, gated };
     }
-    function resolveRecoveryRelaunchProvider(node, failedProviderType, nodeProviderTypes = [], policy, now = Date.now()) {
+    function resolveRecoveryRelaunchProvider(node, failedProviderType, nodeProviderTypes = [], policy, now = Date.now(), context) {
       if (!failedProviderType) return { action: "block" };
-      const block2 = evaluateProviderQuotaGate(node, failedProviderType, policy, now);
+      const block2 = evaluateProviderQuotaGate(node, failedProviderType, policy, now, context);
       if (!block2) return { action: "keep", providerType: failedProviderType };
       const alternatives = nodeProviderTypes.filter((p) => p && p !== failedProviderType);
       if (alternatives.length) {
-        const ranked = rankProvidersByQuotaGate(node, alternatives, policy, now);
+        const ranked = rankProvidersByQuotaGate(node, alternatives, policy, now, context);
         if (ranked.clear.length) {
           return { action: "fallback", providerType: ranked.clear[0], block: block2 };
         }
@@ -57852,9 +57896,9 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       return `QUOTA GATE: skipping recovery relaunch for node ${nodeId} \u2014 ${cause} and the node has no gate-clear alternative${taskId ? `; task ${taskId}` : ""} stays queued until a quota window resets`;
     }
-    function quotaRiskSnapshotForCandidates(node, orderedProviderTypes, policy, now = Date.now()) {
+    function quotaRiskSnapshotForCandidates(node, orderedProviderTypes, policy, now = Date.now(), context) {
       return orderedProviderTypes.map((providerType) => {
-        const w = expiryRiskForRanking(node, providerType, "weekly", policy, now);
+        const w = expiryRiskForRanking(node, providerType, "weekly", policy, now, context);
         return {
           providerType,
           ...w ? { remainingPercent: w.remainingPercent, risk: w.risk } : {}
@@ -57898,6 +57942,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     var init_mesh_quota_routing = __esm2({
       "src/mesh/mesh-quota-routing.ts"() {
         "use strict";
+        init_dist();
         init_repo_mesh_types();
         PROVIDER_QUOTA_SESSION_LOW_SKIP_REASON = "provider_quota_session_low";
         PROVIDER_QUOTA_WEEKLY_LOW_SKIP_REASON = "provider_quota_weekly_low";
@@ -61937,7 +61982,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         LOG2.info("MeshQueue", `Deferring queue claim for node ${nodeId} (${sessionId}): an auto fast-forward is mutating its workspace \u2014 task left pending, claim re-fires next tick`);
         return false;
       }
-      const quotaClaimBlock = evaluateProviderQuotaGate(node, providerType, mesh?.policy?.quotaRouting ?? null);
+      const quotaClaimBlock = evaluateProviderQuotaGate(node, providerType, mesh?.policy?.quotaRouting ?? null, Date.now(), mesh);
       if (quotaClaimBlock) {
         if (quotaClaimBlock.reason === PROVIDER_QUOTA_EXHAUSTED_SKIP_REASON) {
           LOG2.info("MeshQueue", `QUOTA GATE: deferring queue claim for node ${nodeId} (${sessionId}): provider '${providerType}' reported its quota EXHAUSTED \u2014 task left pending until the quota resets`);
@@ -62414,7 +62459,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         retractActionableSkipIfPreviouslyNotified(meshId, taskId);
       }
     }
-    async function resolveUsableProvider(components, nodeId, node, meshId, requiredTags, task, quotaRouting) {
+    async function resolveUsableProvider(components, nodeId, node, meshId, requiredTags, task, quotaRouting, quotaFactsContext) {
       const providerLoader = components.providerLoader;
       if (!providerLoader) return { reason: "provider_loader_unavailable" };
       const slots = resolveNodeCapabilitySlots(node, meshId);
@@ -62462,8 +62507,8 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       if (!candidates.length) {
         return { reason: `provider_priority_unusable: ${failed.join("; ") || nodeId}` };
       }
-      const ranked = rankProvidersByQuotaGate(node, candidates.map((c) => c.providerType), quotaRouting);
-      const riskSnapshot = quotaRiskSnapshotForCandidates(node, ranked.clear, quotaRouting);
+      const ranked = rankProvidersByQuotaGate(node, candidates.map((c) => c.providerType), quotaRouting, Date.now(), quotaFactsContext);
+      const riskSnapshot = quotaRiskSnapshotForCandidates(node, ranked.clear, quotaRouting, Date.now(), quotaFactsContext);
       if (!ranked.clear.length) {
         const detail = ranked.gated.map((g) => `${g.providerType}: ${g.block.reason}`).join("; ");
         LOG2.info("MeshQueue", `QUOTA GATE: every usable provider on node ${nodeId} is quota-gated (${detail}); leaving the task queued until a quota window resets`);
@@ -62714,7 +62759,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
           }
           autoLaunchInProgress.add(launchKey);
           try {
-            const resolved = await resolveUsableProvider(components, nodeId, node, meshId, task.requiredTags, { difficulty: task.difficulty, requiredTags: task.requiredTags }, mesh?.policy?.quotaRouting ?? null);
+            const resolved = await resolveUsableProvider(components, nodeId, node, meshId, task.requiredTags, { difficulty: task.difficulty, requiredTags: task.requiredTags }, mesh?.policy?.quotaRouting ?? null, mesh);
             if (!resolved.providerType) {
               markSkip(nodeId, resolved.reason || "provider_unusable");
               continue;
@@ -64955,6 +65000,68 @@ ${cleanBody}`;
         recentReadDebugSignatureBySession = /* @__PURE__ */ new Map();
       }
     });
+    function readNonEmptyString3(value) {
+      return typeof value === "string" && value.trim() ? value.trim() : "";
+    }
+    function resolveLocalDaemonIds(components) {
+      const statusInstanceId = readNonEmptyString3(components.statusInstanceId);
+      const machineId = readNonEmptyString3(loadConfig2().machineId);
+      return expandDaemonIdForms([statusInstanceId, machineId]);
+    }
+    function scheduleTaskCompletionSideEffectEvidence(components, args) {
+      if (args.taskMode !== "code_change") return;
+      if (!args.taskId) return;
+      const nodeId = args.nodeId;
+      if (!nodeId) return;
+      setImmediate(() => {
+        (async () => {
+          try {
+            const mesh = getMesh(args.meshId);
+            const node = mesh?.nodes.find((n) => meshNodeIdMatches(n, nodeId));
+            const workspace = readNonEmptyString3(node?.workspace);
+            if (!workspace) return;
+            const nodeDaemonId = node ? readMeshNodeDaemonId(node) : void 0;
+            if (nodeDaemonId) {
+              const localDaemonIds = resolveLocalDaemonIds(components);
+              const isLocal = localDaemonIds.some((id) => daemonIdsEquivalent(id, nodeDaemonId));
+              if (!isLocal) return;
+            }
+            const status = await getGitRepoStatus(workspace, { includeSubmodules: false });
+            if (!status.isGitRepo) return;
+            if (status.dirty) return;
+            appendLedgerEntry(args.meshId, {
+              kind: "task_completion_no_side_effects",
+              nodeId,
+              sessionId: args.sessionId,
+              taskId: args.taskId,
+              payload: {
+                taskId: args.taskId,
+                sessionId: args.sessionId,
+                nodeId,
+                workspace,
+                gitDirty: false,
+                changedFiles: 0,
+                reason: "no_side_effects"
+              }
+            });
+          } catch (e) {
+            LOG2.warn("MeshLedger", `Skipped completion side-effect evidence check for task ${args.taskId}: ${e?.message || e}`);
+          }
+        })();
+      });
+    }
+    var init_mesh_completion_side_effect_evidence = __esm2({
+      "src/mesh/mesh-completion-side-effect-evidence.ts"() {
+        "use strict";
+        init_config();
+        init_mesh_config();
+        init_git_status();
+        init_logger();
+        init_dist();
+        init_mesh_ledger();
+        init_mesh_node_identity();
+      }
+    });
     function readLiveTurnPendingEvidence(instance) {
       const candidate = instance;
       try {
@@ -65968,7 +66075,7 @@ ${cleanBody}`;
           }
         }
         setImmediate(() => cleanupTerminalDirectDispatches());
-        return task ? { id: task.id } : null;
+        return task ? { id: task.id, taskMode: task.taskMode } : null;
       }
       let completedTaskForLedger = null;
       let directDispatchTaskIdForLedger;
@@ -66273,6 +66380,15 @@ ${cleanBody}`;
               ...completionEvidence ? completionEvidence.workerResult.source === "default" ? { evidenceLevel: "insufficient", reviewRecommended: true } : { evidenceLevel: "sufficient" } : {}
             }
           });
+          if (ledgerKind === "task_completed") {
+            scheduleTaskCompletionSideEffectEvidence(components, {
+              meshId: args.meshId,
+              taskId: completedTaskForLedger?.id || directDispatchTaskIdForLedger || void 0,
+              taskMode: completedTaskForLedger?.taskMode,
+              sessionId: ledgerSessionId,
+              nodeId: ledgerNodeId
+            });
+          }
         } catch (e) {
           LOG2.warn("MeshLedger", `Failed to record ${ledgerKind}: ${e?.message || e}`);
         }
@@ -66318,7 +66434,9 @@ ${cleanBody}`;
                   node,
                   recoveryContext.failedProviderType,
                   resolveNodeCapabilitySlots(node, args.meshId).map((s2) => s2.provider),
-                  mesh?.policy?.quotaRouting ?? null
+                  mesh?.policy?.quotaRouting ?? null,
+                  Date.now(),
+                  mesh
                 ) : { action: "block" };
                 const relaunchProviderType = relaunch.action === "block" ? null : relaunch.providerType;
                 if (node) {
@@ -66769,6 +66887,7 @@ ${cleanBody}`;
         init_mesh_json_config();
         init_mesh_quota_routing();
         init_mesh_node_slots();
+        init_mesh_completion_side_effect_evidence();
         init_dist();
         init_mesh_events_stale();
         init_mesh_task_inflight();
@@ -68729,6 +68848,17 @@ ${cleanBody}`;
         return void 0;
       }
     }
+    function localGeneratingLabelIsContradicted(components, sessionId) {
+      try {
+        const probe = resolveLiveTurnPendingEvidence(components, sessionId);
+        if (!probe) return false;
+        if (probe()) return false;
+        LOG2.info("MeshReconcile", `Session ${sessionId} reports FSM status 'generating' but its adapter has no live turn evidence \u2014 treating the label as stale so the early transcript-evidence rescue may evaluate it (the completion arm was likely orphaned by a continuity cancel)`);
+        return true;
+      } catch {
+        return false;
+      }
+    }
     async function evaluateEarlyIdleTranscriptArm(components, mesh, store, row, localDaemonId, selfIds = []) {
       const sessionId = readNonEmptyString(row.assignedSessionId);
       if (!sessionId) return false;
@@ -68744,7 +68874,9 @@ ${cleanBody}`;
         }
       }
       const verdict = resolveSessionBusyVerdict(components, sessionId);
-      if (verdict === "GENERATING") return false;
+      if (verdict === "GENERATING" && !localGeneratingLabelIsContradicted(components, sessionId)) {
+        return false;
+      }
       if (verdict === "UNKNOWN") {
         const nodeId = readNonEmptyString(row.assignedNodeId);
         const node = (mesh.nodes ?? []).find((n) => n.id === nodeId);
@@ -93152,6 +93284,45 @@ ${marker}`,
     init_config();
     init_install();
     init_logger();
+    var SEMVER_PATTERN = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+    var NUMERIC_IDENTIFIER = /^\d+$/;
+    function parseSemver(version2) {
+      if (typeof version2 !== "string") return null;
+      const match = version2.trim().replace(/^v/, "").match(SEMVER_PATTERN);
+      if (!match) return null;
+      return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        prerelease: match[4] ? match[4].split(".") : []
+      };
+    }
+    function comparePrerelease(a, b) {
+      if (a.length === 0 && b.length === 0) return 0;
+      if (a.length === 0) return 1;
+      if (b.length === 0) return -1;
+      for (let i = 0; i < Math.min(a.length, b.length); i += 1) {
+        const idA = a[i];
+        const idB = b[i];
+        if (idA === idB) continue;
+        const numA = NUMERIC_IDENTIFIER.test(idA);
+        const numB = NUMERIC_IDENTIFIER.test(idB);
+        if (numA && numB) return Number(idA) < Number(idB) ? -1 : 1;
+        if (numA) return -1;
+        if (numB) return 1;
+        return idA < idB ? -1 : 1;
+      }
+      return a.length === b.length ? 0 : a.length < b.length ? -1 : 1;
+    }
+    function compareSemver(a, b) {
+      const pa = parseSemver(a);
+      const pb = parseSemver(b);
+      if (!pa || !pb) return null;
+      if (pa.major !== pb.major) return pa.major < pb.major ? -1 : 1;
+      if (pa.minor !== pb.minor) return pa.minor < pb.minor ? -1 : 1;
+      if (pa.patch !== pb.patch) return pa.patch < pb.patch ? -1 : 1;
+      return comparePrerelease(pa.prerelease, pb.prerelease);
+    }
     init_track_identity();
     var daemonLifecycleHandlers = {
       daemon_upgrade: async (ctx, args) => {
@@ -93160,10 +93331,22 @@ ${marker}`,
           const isStandalone = ctx.deps.packageName === "@adhdev/daemon-standalone" || process.argv[1]?.includes("daemon-standalone");
           const pkgName = isStandalone ? "@adhdev/daemon-standalone" : "adhdev";
           const npmSurface = resolveCurrentGlobalInstallSurface({ packageName: pkgName });
-          if (args?.channel || args?.updatePolicy?.channel || args?.npmTag) {
-            LOG2.info("Upgrade", "Ignoring deprecated channel hint \u2014 upgrade target is the build track");
+          const requestedChannelRaw = args?.channel ?? args?.updatePolicy?.channel ?? null;
+          const requestedChannel = typeof requestedChannelRaw === "string" && requestedChannelRaw.trim() ? requestedChannelRaw.trim().toLowerCase() : null;
+          const requestedNpmTag = typeof args?.npmTag === "string" && args.npmTag.trim() ? args.npmTag.trim().toLowerCase() : null;
+          if (requestedChannel || requestedNpmTag) {
+            LOG2.info("Upgrade", `Ignoring deprecated channel hint (channel=${requestedChannel ?? "-"}, npmTag=${requestedNpmTag ?? "-"}) \u2014 upgrade target is the build track '${TRACK}'`);
           }
           const npmTag = IDENTITY.npmTag;
+          const channelOverride = requestedChannel && requestedChannel !== TRACK && !(TRACK === "preview" && requestedChannel === "next") && !(TRACK === "stable" && requestedChannel === "latest") || requestedNpmTag && requestedNpmTag !== npmTag ? {
+            requestedChannel,
+            requestedNpmTag,
+            effectiveChannel: TRACK,
+            effectiveNpmTag: npmTag,
+            ignored: true,
+            reason: `The requested channel/tag was IGNORED. Since Phase 3 the release channel is a build-time identity of the installed binary, so this daemon can only upgrade on its own '${TRACK}' track (${pkgName}@${npmTag}). Switching tracks requires installing the other track's package, not an upgrade argument.`
+          } : null;
+          const withChannelNotice = (payload) => channelOverride ? { ...payload, channelOverride } : payload;
           const latest = resolveNpmPublishedVersion(pkgName, npmTag, npmSurface);
           LOG2.info("Upgrade", `Latest ${pkgName}@${npmTag}: v${latest}`);
           let currentInstalled = null;
@@ -93180,11 +93363,39 @@ ${marker}`,
           const runningVersion = typeof ctx.deps.statusVersion === "string" ? ctx.deps.statusVersion.trim().replace(/^v/, "") : null;
           if (currentInstalled === latest && runningVersion === latest) {
             LOG2.info("Upgrade", `Already on ${TRACK} track version v${latest}; skipping install`);
-            return { success: true, upgraded: false, alreadyLatest: true, outcome: "already_latest", version: latest, targetVersion: latest, channel: TRACK, npmTag };
+            return withChannelNotice({ success: true, upgraded: false, alreadyLatest: true, outcome: "already_latest", version: latest, targetVersion: latest, channel: TRACK, npmTag });
           }
           if (currentInstalled === latest && runningVersion && runningVersion !== latest) {
             LOG2.info("Upgrade", `Installed package is v${latest}, but running daemon is v${runningVersion}; scheduling restart`);
           }
+          const direction = runningVersion ? compareSemver(latest, runningVersion) : null;
+          if (direction !== null && direction < 0 && args?.allowDowngrade !== true) {
+            LOG2.warn("Upgrade", `Refusing downgrade: running v${runningVersion} is NEWER than ${TRACK} track target v${latest} (${pkgName}@${npmTag}). Pass allowDowngrade to override.`);
+            return withChannelNotice({
+              success: false,
+              upgraded: false,
+              restarting: false,
+              code: "downgrade_refused",
+              outcome: "downgrade_refused",
+              // Everything the caller needs to see WHY it would go
+              // backwards, without a second round-trip: the incident that
+              // motivated this guard was diagnosable only because someone
+              // noticed the version in the response was lower than the
+              // node's actual version.
+              version: runningVersion,
+              currentVersion: runningVersion,
+              installedVersion: currentInstalled,
+              targetVersion: latest,
+              channel: TRACK,
+              npmTag,
+              packageName: pkgName,
+              reason: `Upgrade refused: it would DOWNGRADE this daemon from v${runningVersion} to v${latest}. The ${TRACK} track dist-tag ${pkgName}@${npmTag} currently resolves to v${latest}, which is older than what is running. This usually means the daemon is resolving the wrong track's package \u2014 check that the npm install surface (global prefix) matches the running build's track. Pass allowDowngrade:true to force the rollback anyway.`,
+              clientHint: "Downgrade refused \u2014 no restart happened and the daemon is untouched. Fix the install surface/track pin, or pass allowDowngrade:true to roll back deliberately."
+            });
+          }
+          if (direction !== null && direction < 0) {
+            LOG2.warn("Upgrade", `allowDowngrade set \u2014 proceeding with DOWNGRADE from v${runningVersion} to v${latest} on the ${TRACK} track`);
+          }
           spawnDetachedDaemonUpgradeHelper({
             packageName: pkgName,
             targetVersion: latest,
@@ -93198,7 +93409,7 @@ ${marker}`,
             LOG2.info("Upgrade", "Exiting daemon so detached upgrader can continue...");
             process.exit(0);
           }, 3e3);
-          return {
+          return withChannelNotice({
             success: true,
             upgraded: true,
             version: latest,
@@ -93207,9 +93418,16 @@ ${marker}`,
             npmTag,
             outcome: "scheduled",
             targetVersion: latest,
+            // No `currentVersion` here on purpose: this response is about a
+            // SCHEDULED move, and daemon-upgrade-scheduled-intent.test.ts
+            // pins that it must not read as "already on the target". The
+            // pre-upgrade version belongs on the refusal payload, where it
+            // is the actual diagnosis. Only the deliberate-override marker
+            // is added, so an intentional rollback stays self-evident.
+            ...direction !== null && direction < 0 ? { downgrade: true } : {},
             upgradeLogPath: getUpgradeLogPath(),
             clientHint: `Upgrade to v${latest} SCHEDULED, not completed \u2014 the detached helper installs and restarts the daemon after this response, and a failure rolls back to the previous version. Check upgradeLogPath (or get_status_metadata.upgradeFailure after the restart) for the actual outcome.`
-          };
+          });
         } catch (e) {
           LOG2.error("Upgrade", `Failed: ${e.message}`);
           return { success: false, error: e.message };
@@ -96961,6 +97179,8 @@ ${marker}`,
     var CANON_C_MISSING_ASSISTANT_MIN_ELAPSED_MS = 2e4;
     var MISSING_ASSISTANT_TRANSCRIPT_GROWTH_QUIET_MS = 6e4;
     var NATIVE_HISTORY_MESH_IDLE_SETTLE_MS = 4e3;
+    var CANCELLED_COMPLETION_RECHECK_MS = 1500;
+    var CANCELLED_COMPLETION_RECHECK_MAX_ATTEMPTS = 4;
     var PTY_PARSED_FINAL_ASSISTANT_QUIET_DWELL_MS = 1200;
     var ANTIGRAVITY_HOLD_QUIET_DWELL_MS = 3e3;
     var ANTIGRAVITY_HOLD_HARD_CAP_MS = 5 * 6e4;
@@ -98019,7 +98239,7 @@ ${buttons.join("\n")}`;
         timestamp: Date.now(),
         taskId,
         finalSummary,
-        evidenceLevel: "transcript",
+        evidenceLevel: "reported",
         completionDiagnostic: { source: "pre_cleanup_transcript_completion" }
       });
       return true;
@@ -98068,7 +98288,7 @@ ${buttons.join("\n")}`;
         timestamp: Date.now(),
         taskId,
         finalSummary,
-        evidenceLevel: "transcript",
+        evidenceLevel: "reported",
         completionDiagnostic: { source: diagnosticSource }
       });
       return true;
@@ -98510,6 +98730,64 @@ ${buttons.join("\n")}`;
         host.pushEvent({ event: me.type, agentKey: me.agentKey, message: me.message, elapsedSec: me.elapsedSec, timestamp: me.timestamp });
       }
     }
+    init_logger();
+    function armCancelledCompletionRecheck(host, pending, reason) {
+      if (reason === "new_pty_output") return;
+      const now = Date.now();
+      const prior = host.cancelledCompletionRecheck;
+      const carriedPending = prior?.pending ?? pending;
+      const attempts = prior ? prior.attempts : 0;
+      if (attempts >= CANCELLED_COMPLETION_RECHECK_MAX_ATTEMPTS) {
+        clearCancelledCompletionRecheck(host);
+        LOG2.debug("CLI", `[${host.type}] cancelled-completion recheck budget exhausted (${reason}) \u2014 deferring to the next FSM completion edge`);
+        return;
+      }
+      host.cancelledCompletionRecheck = {
+        pending: carriedPending,
+        reason,
+        attempts,
+        firstCancelledAt: prior?.firstCancelledAt ?? now
+      };
+      if (host.cancelledCompletionRecheckTimer) clearTimeout(host.cancelledCompletionRecheckTimer);
+      host.cancelledCompletionRecheckTimer = setTimeout(
+        () => runCancelledCompletionRecheck(host),
+        CANCELLED_COMPLETION_RECHECK_MS
+      );
+    }
+    function clearCancelledCompletionRecheck(host) {
+      if (host.cancelledCompletionRecheckTimer) {
+        clearTimeout(host.cancelledCompletionRecheckTimer);
+        host.cancelledCompletionRecheckTimer = null;
+      }
+      host.cancelledCompletionRecheck = null;
+    }
+    function runCancelledCompletionRecheck(host) {
+      host.cancelledCompletionRecheckTimer = null;
+      const watch3 = host.cancelledCompletionRecheck;
+      if (!watch3) return;
+      if (host.completedDebouncePending) {
+        clearCancelledCompletionRecheck(host);
+        return;
+      }
+      watch3.attempts += 1;
+      LOG2.info("CLI", `[${host.type}] re-checking completion cancelled by ${watch3.reason} (attempt ${watch3.attempts}/${CANCELLED_COMPLETION_RECHECK_MAX_ATTEMPTS}, ${Date.now() - watch3.firstCancelledAt}ms since cancel)`);
+      if (host.completionTraceOn()) host.recordCompletionGateTrace("cancel_recheck", {
+        reason: watch3.reason,
+        attempt: watch3.attempts,
+        sinceCancelMs: Date.now() - watch3.firstCancelledAt,
+        busyEpoch: host.busyEpoch
+      });
+      const lastOutputAt = host.adapter.getStatus({ allowParse: false })?.lastOutputAt;
+      host.completedDebouncePending = {
+        ...watch3.pending,
+        busyEpochAtArm: host.busyEpoch,
+        lastOutputAtArm: typeof lastOutputAt === "number" && Number.isFinite(lastOutputAt) ? lastOutputAt : watch3.pending.lastOutputAtArm
+      };
+      host.flushCompletedDebounceIfFinalized();
+      if (host.cancelledCompletionRecheck === watch3 && host.completedDebouncePending) {
+        clearCancelledCompletionRecheck(host);
+      }
+    }
     init_contracts2();
     var MAX_TRACKED_MESSAGES = 2e3;
     function hasUsableTimestamp(message) {
@@ -99669,11 +99947,20 @@ ${buttons.join("\n")}`;
           clearTimeout(this.autoApproveBusyTimer);
           this.autoApproveBusyTimer = null;
         }
+        this.clearCancelledCompletionRecheck();
         this.appliedEffectKeys.clear();
         closeSqliteProbeCache(this.sqliteProbeCache);
       }
       completedDebounceTimer = null;
       completedDebouncePending = null;
+      /**
+       * (CANCEL-BLIP-ORPHAN) Re-verification watch for an arm the continuity cancel just
+       * deleted — the cancelled arm's snapshot plus a bounded recheck budget, so a
+       * sub-second PTY blip cannot permanently orphan the completion. Full rationale:
+       * completion/cancel-recheck.ts.
+       */
+      cancelledCompletionRecheck = null;
+      cancelledCompletionRecheckTimer = null;
       lastExternalCompletionProbe = null;
       // (NATIVE-TURN-SIGNAL) Terminal markers from the last native transcript read. Refreshed
       // on every completion probe; null when the provider surfaces none.
@@ -100120,6 +100407,17 @@ ${buttons.join("\n")}`;
         if (this.completedDebounceTimer) clearTimeout(this.completedDebounceTimer);
         this.completedDebounceTimer = setTimeout(() => this.flushCompletedDebounceIfFinalized(), delayMs);
       }
+      /**
+       * (CANCEL-BLIP-ORPHAN) Post-cancel completion re-verification. The judgment and its
+       * full rationale live in completion/cancel-recheck.ts; these are the host-dispatched
+       * seams, matching the status-transition / evidence / stall-rescue moves.
+       */
+      armCancelledCompletionRecheck(pending, reason) {
+        armCancelledCompletionRecheck(this, pending, reason);
+      }
+      clearCancelledCompletionRecheck() {
+        clearCancelledCompletionRecheck(this);
+      }
       // EVTTRACE (observation-only): is this a mesh worker session whose completion
       // events must route to a coordinator? Used purely to gate trace logging so a
       // non-mesh CLI session's completions don't add EvtTrace noise. No decision logic.
@@ -100651,6 +100949,7 @@ ${buttons.join("\n")}`;
           if (this.completionTraceOn()) this.recordCompletionGateTrace("cancel", { blockReason: decision.reason, ...decision.trace });
           this.completedDebouncePending = null;
           this.completedDebounceTimer = null;
+          this.armCancelledCompletionRecheck(pending, decision.reason);
           return;
         }
         this.applyCompletionArmPatch(pending, decision.armPatch);
@@ -100708,6 +101007,7 @@ ${buttons.join("\n")}`;
           });
           this.completedDebouncePending = null;
           this.completedDebounceTimer = null;
+          this.clearCancelledCompletionRecheck();
           this.generatingStartedAt = 0;
           this.lastApprovalEventFingerprint = "";
           this.markCurrentTurnStartupGraceCollapseSatisfied();
@@ -100734,7 +101034,7 @@ ${buttons.join("\n")}`;
           timestamp: pending.timestamp,
           taskId: pending.taskId,
           finalSummary,
-          evidenceLevel: "transcript",
+          evidenceLevel: "reported",
           completionDiagnostic: {
             source: "clean_final_assistant",
             cleanPath: true,
@@ -100762,6 +101062,7 @@ ${buttons.join("\n")}`;
         });
         this.completedDebouncePending = null;
         this.completedDebounceTimer = null;
+        this.clearCancelledCompletionRecheck();
         this.generatingStartedAt = 0;
         this.lastApprovalEventFingerprint = "";
         this.markCurrentTurnStartupGraceCollapseSatisfied();
@@ -100873,7 +101174,7 @@ ${buttons.join("\n")}`;
        *   • prior emit was WEAK → re-arm ONE-SHOT, but only across a real generating→idle
        *     transition: require busyEpoch to have advanced past the weak emit's epoch, so a
        *     static idle screen cannot re-fire the same weak frame. The genuine re-emit passes
-       *     evidenceLevel:'transcript' (non-weak), overwriting the latch → any subsequent idle
+       *     evidenceLevel:'reported' (non-weak), overwriting the latch → any subsequent idle
        *     tick hits the now-genuine latch and is suppressed. Never a third emit.
        */
       shouldSuppressCompletionReEmit(taskId) {
@@ -110507,7 +110808,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             ...slots.length ? { slots } : {}
           };
           if (providerRoles.length) migrateProviderRolesToSlots2(policy);
-          if (!providerPriority.length) syncProviderPriorityFromSlots(policy);
+          syncProviderPriorityFromSlots(policy);
           const role = normalizeMeshDaemonRole(args?.role);
           const daemonId = typeof args?.daemonId === "string" && args.daemonId.trim() ? args.daemonId.trim() : void 0;
           const machineId = typeof args?.machineId === "string" && args.machineId.trim() ? args.machineId.trim() : void 0;
@@ -110559,10 +110860,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             else delete policy.providerRoles;
           }
           migrateProviderRolesToSlots2(policy);
-          if (!Array.isArray(args?.providerPriority) && !Object.prototype.hasOwnProperty.call(policy, "providerPriority")) {
-            const finalSlots = Object.prototype.hasOwnProperty.call(policy, "slots") ? policy.slots : getMesh2(meshId)?.nodes.find((n) => n.id === nodeId)?.policy?.slots;
-            syncProviderPriorityFromSlots(policy, finalSlots);
-          }
+          const finalSlots = Object.prototype.hasOwnProperty.call(policy, "slots") ? policy.slots : getMesh2(meshId)?.nodes.find((n) => n.id === nodeId)?.policy?.slots;
+          syncProviderPriorityFromSlots(policy, finalSlots);
           const patch = { policy };
           if (typeof args?.systemPrompt === "string") {
             const trimmed = args.systemPrompt.trim();
@@ -110587,9 +110886,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             ...inlineNode.policy && typeof inlineNode.policy === "object" && !Array.isArray(inlineNode.policy) ? inlineNode.policy : {},
             ...patch.policy
           };
-          if (!Array.isArray(args?.providerPriority) && !Object.prototype.hasOwnProperty.call(patch.policy, "providerPriority")) {
-            syncProviderPriorityFromSlots(inlineNode.policy);
-          }
+          syncProviderPriorityFromSlots(inlineNode.policy);
           if (Object.prototype.hasOwnProperty.call(patch, "systemPrompt")) {
             const sp = patch.systemPrompt;
             if (typeof sp === "string" && sp.trim()) inlineNode.systemPrompt = sp;
@@ -113593,6 +113890,7 @@ ${ptyResult.output.slice(-2e3)}`);
     init_dist();
     init_mesh_events();
     init_mesh_reconcile_identity();
+    init_mesh_reconcile_acked_hold();
     init_mesh_fast_forward();
     var import_node_child_process7 = require("child_process");
     var import_node_util5 = require("util");
@@ -115595,11 +115893,20 @@ ${mergeTreeErr?.stderr || ""}`;
         LOG2.warn("Mesh", `[Refinery] Failed to append async refine ledger entry: ${e?.message || e}`);
       }
     }
+    function resolveRefineResumeDispatchGraceMs() {
+      return resolveTunedReconcileMs("MESH_REFINE_RESUME_DISPATCH_GRACE_MS", 6e4, 0, 10 * 6e4);
+    }
+    function resolveRefineResumeZombieCutoffMs() {
+      return resolveTunedReconcileMs("MESH_REFINE_RESUME_ZOMBIE_CUTOFF_MS", 24 * 60 * 6e4, 5 * 6e4, 30 * 24 * 60 * 6e4);
+    }
     async function resumePendingRefineJobsOnStartup(self) {
       try {
         const { listMeshes: listMeshes2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
         const { readLedgerEntries: readLedgerEntries2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
         const meshIds = listMeshes2().map((m) => m.id).filter(Boolean);
+        const nowMs = Date.now();
+        const dispatchGraceMs = resolveRefineResumeDispatchGraceMs();
+        const zombieCutoffMs = resolveRefineResumeZombieCutoffMs();
         for (const meshId of meshIds) {
           const entries = readLedgerEntries2(meshId, { kind: ["task_dispatched", "task_completed", "task_failed"] });
           const terminal = /* @__PURE__ */ new Set();
@@ -115617,10 +115924,44 @@ ${mergeTreeErr?.stderr || ""}`;
             if (!jobId || terminal.has(`${e.nodeId}:${jobId}`)) continue;
             const key2 = buildRefineJobKey(self, meshId, e.nodeId);
             if (self.runningRefineJobs.has(key2)) continue;
+            const dispatchedAtMs = new Date(e.timestamp).getTime();
+            const ageMs2 = Number.isFinite(dispatchedAtMs) ? nowMs - dispatchedAtMs : void 0;
+            if (ageMs2 !== void 0 && ageMs2 >= 0 && ageMs2 < dispatchGraceMs) {
+              LOG2.info("Mesh", `[Refinery] Deferring resume of refine job for node ${e.nodeId} (jobId=${jobId}) \u2014 dispatched ${ageMs2}ms ago, within the ${dispatchGraceMs}ms grace window; may still be running.`);
+              continue;
+            }
+            if (ageMs2 !== void 0 && ageMs2 >= zombieCutoffMs) {
+              const node = e.payload?.refineJob;
+              const coordinatorDaemonId2 = node?.targetCoordinatorDaemonId;
+              const coordinatorSessionId2 = node?.targetCoordinatorSessionId;
+              const zombieHandle = buildRefineJobHandle(self, {
+                meshId,
+                nodeId: e.nodeId,
+                jobId,
+                interactionId: typeof node?.interactionId === "string" ? node.interactionId : void 0,
+                status: "failed",
+                startedAt: typeof node?.startedAt === "string" ? node.startedAt : e.timestamp,
+                completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                coordinatorDaemonId: coordinatorDaemonId2,
+                coordinatorSessionId: coordinatorSessionId2
+              });
+              LOG2.warn("Mesh", `[Refinery] Closing out stale refine job for node ${e.nodeId} (jobId=${jobId}) as failed \u2014 dispatched ${ageMs2}ms ago, past the ${zombieCutoffMs}ms zombie cutoff with no terminal entry; not resuming.`);
+              const zombieResult = {
+                success: false,
+                code: "resume_abandoned_stale_dispatch",
+                error: `Refine job dispatched at ${e.timestamp} never reached a terminal state and exceeded the ${zombieCutoffMs}ms zombie cutoff on daemon restart; closed out without resuming.`
+              };
+              await appendRefineJobLedger(self, "task_failed", zombieHandle, zombieResult);
+              queueRefineJobEvent(self, "refine:failed", zombieHandle, zombieResult);
+              continue;
+            }
             const coordinatorDaemonId = e.payload?.refineJob?.targetCoordinatorDaemonId;
+            const coordinatorSessionId = e.payload?.refineJob?.targetCoordinatorSessionId;
             LOG2.info("Mesh", `[Refinery] Auto-resuming interrupted refine job for node ${e.nodeId} (jobId=${jobId})`);
             void startMeshRefineJob(self, meshId, e.nodeId, {
-              coordinatorDaemonId
+              jobId,
+              coordinatorDaemonId,
+              coordinatorSessionId
             });
           }
         }
@@ -117344,7 +117685,7 @@ ${e?.stderr || ""}`;
       const terminal = self.terminalRefineJobs.get(key2);
       const alreadyRunning = self.runningRefineJobs.get(key2);
       if (alreadyRunning) return { ...alreadyRunning, duplicate: true };
-      const jobId = `refine_${createInteractionId()}`;
+      const jobId = typeof args?.jobId === "string" && args.jobId.trim() ? args.jobId.trim() : `refine_${createInteractionId()}`;
       const interactionId = createInteractionId();
       const placeholder = buildRefineJobHandle(self, { meshId, nodeId, jobId, interactionId, retryOfJobId: terminal?.jobId });
       self.runningRefineJobs.set(key2, placeholder);