npm - @adhdev/daemon-standalone - Versions diffs - 0.9.82-rc.412 → 0.9.82-rc.414 - Mend

@adhdev/daemon-standalone 0.9.82-rc.412 → 0.9.82-rc.414

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/index.js +446 -387
package/dist/index.js.map +1 -1
package/package.json +1 -1
package/vendor/mcp-server/index.js +3 -2
package/vendor/mcp-server/index.js.map +1 -1

package/dist/index.js CHANGED Viewed

@@ -29727,9 +29727,9 @@ var require_dist3 = __commonJS({
     };
     var __copyProps2 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames2(from))
-          if (!__hasOwnProp2.call(to, key) && key !== except)
-            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+        for (let key2 of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key2) && key2 !== except)
+            __defProp2(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc2(from, key2)) || desc.enumerable });
       }
       return to;
     };
@@ -30115,10 +30115,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "f8bbe838081c3b3e14df690b3ed24568979f635e" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "f8bbe838" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.412" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-28T10:27:49.415Z" : void 0);
+      const commit = readInjected(true ? "7a774e95a82354f5357197b3c84f63e68b5f7a5d" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "7a774e95" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.414" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-28T11:51:23.191Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -30134,18 +30134,18 @@ var require_dist3 = __commonJS({
     function isStringArray(value) {
       return Array.isArray(value) && value.every((v) => typeof v === "string" && v.length > 0);
     }
-    function validateTarget(value, key, errors) {
+    function validateTarget(value, key2, errors) {
       if (!isRecord(value)) {
-        errors.push(`impactTargets.${key} must be an object`);
+        errors.push(`impactTargets.${key2} must be an object`);
         return void 0;
       }
       const { recommendedCommand } = value;
       if (typeof recommendedCommand !== "string" || !recommendedCommand.length) {
-        errors.push(`impactTargets.${key}.recommendedCommand must be a non-empty string`);
+        errors.push(`impactTargets.${key2}.recommendedCommand must be a non-empty string`);
         return void 0;
       }
       for (const k of Object.keys(value)) {
-        if (k !== "recommendedCommand") errors.push(`impactTargets.${key}.${k} is not a recognized field (only recommendedCommand)`);
+        if (k !== "recommendedCommand") errors.push(`impactTargets.${key2}.${k} is not a recognized field (only recommendedCommand)`);
       }
       return { recommendedCommand };
     }
@@ -30172,20 +30172,20 @@ var require_dist3 = __commonJS({
           errors.push("impactTargets must be an object");
         } else {
           const targets = {};
-          for (const key of Object.keys(raw.impactTargets)) {
-            if (key !== "daemon" && key !== "web" && key !== "none") {
-              errors.push(`impactTargets.${key} is not a recognized impact kind (daemon|web|none)`);
+          for (const key2 of Object.keys(raw.impactTargets)) {
+            if (key2 !== "daemon" && key2 !== "web" && key2 !== "none") {
+              errors.push(`impactTargets.${key2} is not a recognized impact kind (daemon|web|none)`);
               continue;
             }
-            const target = validateTarget(raw.impactTargets[key], key, errors);
-            if (target) targets[key] = target;
+            const target = validateTarget(raw.impactTargets[key2], key2, errors);
+            if (target) targets[key2] = target;
           }
           if (Object.keys(targets).length) config2.impactTargets = targets;
         }
       }
-      for (const key of Object.keys(raw)) {
-        if (!["daemonRuntimePackages", "webOnlyPackages", "nonRuntimeRootFilePatterns", "impactTargets"].includes(key)) {
-          errors.push(`unknown config key '${key}'`);
+      for (const key2 of Object.keys(raw)) {
+        if (!["daemonRuntimePackages", "webOnlyPackages", "nonRuntimeRootFilePatterns", "impactTargets"].includes(key2)) {
+          errors.push(`unknown config key '${key2}'`);
         }
       }
       return { valid: errors.length === 0, errors, config: errors.length === 0 ? config2 : void 0 };
@@ -30519,12 +30519,12 @@ var require_dist3 = __commonJS({
         return { config: null, sourceKey: "forced-default" };
       }
       if (options.changeImpactConfig !== void 0) {
-        let key = "injected";
+        let key2 = "injected";
         try {
-          key = `injected:${JSON.stringify(options.changeImpactConfig)}`;
+          key2 = `injected:${JSON.stringify(options.changeImpactConfig)}`;
         } catch {
         }
-        return { config: options.changeImpactConfig, sourceKey: key };
+        return { config: options.changeImpactConfig, sourceKey: key2 };
       }
       if (!repoRoot) {
         return { config: null, sourceKey: "no-repo-root" };
@@ -32103,9 +32103,9 @@ ${error48.message || ""}`;
       ].filter(Boolean)));
       const nextSessionNotificationDismissals = { ...state.sessionNotificationDismissals || {} };
       const nextSessionNotificationUnreadOverrides = { ...state.sessionNotificationUnreadOverrides || {} };
-      for (const key of dismissalKeys) {
-        nextSessionNotificationDismissals[key] = dismissalId;
-        delete nextSessionNotificationUnreadOverrides[key];
+      for (const key2 of dismissalKeys) {
+        nextSessionNotificationDismissals[key2] = dismissalId;
+        delete nextSessionNotificationUnreadOverrides[key2];
       }
       return {
         ...state,
@@ -32122,9 +32122,9 @@ ${error48.message || ""}`;
       ].filter(Boolean)));
       const nextSessionNotificationDismissals = { ...state.sessionNotificationDismissals || {} };
       const nextSessionNotificationUnreadOverrides = { ...state.sessionNotificationUnreadOverrides || {} };
-      for (const key of unreadKeys) {
-        nextSessionNotificationUnreadOverrides[key] = unreadId;
-        delete nextSessionNotificationDismissals[key];
+      for (const key2 of unreadKeys) {
+        nextSessionNotificationUnreadOverrides[key2] = unreadId;
+        delete nextSessionNotificationDismissals[key2];
       }
       return {
         ...state,
@@ -32188,11 +32188,11 @@ ${error48.message || ""}`;
       const nextSessionReadMarkers = { ...prevMarkers };
       const nextSessionNotificationDismissals = { ...state.sessionNotificationDismissals || {} };
       const nextSessionNotificationUnreadOverrides = { ...state.sessionNotificationUnreadOverrides || {} };
-      for (const key of readKeys) {
-        nextSessionReads[key] = Math.max(prev[key] || 0, seenAt);
-        if (nextMarker) nextSessionReadMarkers[key] = nextMarker;
-        delete nextSessionNotificationDismissals[key];
-        delete nextSessionNotificationUnreadOverrides[key];
+      for (const key2 of readKeys) {
+        nextSessionReads[key2] = Math.max(prev[key2] || 0, seenAt);
+        if (nextMarker) nextSessionReadMarkers[key2] = nextMarker;
+        delete nextSessionNotificationDismissals[key2];
+        delete nextSessionNotificationUnreadOverrides[key2];
       }
       return {
         ...state,
@@ -32893,6 +32893,12 @@ ${error48.message || ""}`;
       }
       return trimmed;
     }
+    function canonicalDaemonId(id) {
+      const core = machineCoreFromDaemonId(id);
+      if (!core) return void 0;
+      if (!core.startsWith("mach_")) return core;
+      return `daemon_${core}`;
+    }
     function daemonIdsEquivalent(a, b) {
       const coreA = machineCoreFromDaemonId(a);
       const coreB = machineCoreFromDaemonId(b);
@@ -33052,8 +33058,8 @@ Default branch: \`${mesh.defaultBranch}\`` : ""}`);
         rules: buildRulesSection(coordinatorCliType),
         toolExposurePreflight: TOOL_EXPOSURE_PREFLIGHT_SECTION
       };
-      return template.replace(/\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g, (m, key) => {
-        return Object.prototype.hasOwnProperty.call(replacements, key) ? replacements[key] : m;
+      return template.replace(/\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g, (m, key2) => {
+        return Object.prototype.hasOwnProperty.call(replacements, key2) ? replacements[key2] : m;
       });
     }
     function buildNodeStatusSection(nodes) {
@@ -34493,6 +34499,31 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         ]);
       }
     });
+    function key(meshId, taskId) {
+      return `${meshId}::${taskId}`;
+    }
+    function beginTaskDispatchInFlight(meshId, taskId) {
+      if (!meshId || !taskId) return false;
+      const k = key(meshId, taskId);
+      if (inFlight.has(k)) return false;
+      inFlight.add(k);
+      return true;
+    }
+    function isTaskDispatchInFlight(meshId, taskId) {
+      if (!meshId || !taskId) return false;
+      return inFlight.has(key(meshId, taskId));
+    }
+    function endTaskDispatchInFlight(meshId, taskId) {
+      if (!meshId || !taskId) return;
+      inFlight.delete(key(meshId, taskId));
+    }
+    var inFlight;
+    var init_mesh_task_inflight = __esm2({
+      "src/mesh/mesh-task-inflight.ts"() {
+        "use strict";
+        inFlight = /* @__PURE__ */ new Set();
+      }
+    });
     var mesh_work_queue_exports = {};
     __export2(mesh_work_queue_exports, {
       ACTIVE_MESH_QUEUE_STATUSES: () => ACTIVE_MESH_QUEUE_STATUSES,
@@ -34758,14 +34789,14 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       if (!Array.isArray(raw)) return void 0;
       return raw.find((type) => typeof type === "string" && type.trim())?.trim();
     }
-    function readNodeOverride(node, key) {
+    function readNodeOverride(node, key2) {
       const overrides = node?.userOverrides;
       if (!overrides || typeof overrides !== "object" || Array.isArray(overrides)) return null;
-      const value = overrides[key];
+      const value = overrides[key2];
       return typeof value === "string" && value.trim() ? value.trim() : null;
     }
-    function readNodeReporter(node, key) {
-      const value = key === "platform" ? node?.reportedPlatform : node?.reportedArch;
+    function readNodeReporter(node, key2) {
+      const value = key2 === "platform" ? node?.reportedPlatform : node?.reportedArch;
       return typeof value === "string" && value.trim() ? value.trim() : null;
     }
     function buildMeshNodeCapabilityTags(node, providerType) {
@@ -34984,6 +35015,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         if (!entry) return null;
         entry.status = status;
         MeshRuntimeStore.getInstance().updateQueueEntry(entry);
+        if (status !== "assigned") endTaskDispatchInFlight(meshId, taskId);
         if (DEPENDENCY_FAILURE_TERMINALS.has(status)) propagateDependencyFailure(meshId, taskId);
         return entry;
       });
@@ -35008,6 +35040,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         entry.cancelledAt = now;
         if (opts?.reason) entry.cancelReason = opts.reason;
         MeshRuntimeStore.getInstance().updateQueueEntry(entry);
+        endTaskDispatchInFlight(meshId, taskId);
         propagateDependencyFailure(meshId, taskId);
         return entry;
       });
@@ -35017,6 +35050,11 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       return withQueueLock(meshId, () => {
         const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
         if (!entry) return null;
+        if (!opts?.force && isTaskDispatchInFlight(meshId, taskId)) {
+          LOG2.warn("MeshQueue", `Refusing to requeue task ${taskId} on mesh ${meshId}: it is actively dispatched/generating (single-flight in-flight). Requeueing now would open a duplicate second dispatch into another session. Pass force to override.`);
+          return entry;
+        }
+        endTaskDispatchInFlight(meshId, taskId);
         const currentCount = entry.requeueCount || 0;
         const maxRetries = opts?.maxRetries ?? entry.maxRetries ?? 1;
         if (!opts?.force && currentCount >= maxRetries) {
@@ -35061,6 +35099,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         delete entry.dispatchTimestamp;
         entry.strandedReclaimCount = reclaims;
         entry.updatedAt = now;
+        endTaskDispatchInFlight(meshId, taskId);
         if (reclaims > MAX_STRANDED_RECLAIMS) {
           entry.status = "failed";
           entry.cancelReason = `stranded_dispatch_unrecovered: reclaimed ${reclaims - 1} time(s) without a confirmed dispatch`;
@@ -35104,6 +35143,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         }
         entry.status = status;
         store.updateQueueEntry(entry);
+        if (status !== "assigned") endTaskDispatchInFlight(meshId, entry.id);
         if (DEPENDENCY_FAILURE_TERMINALS.has(status)) propagateDependencyFailure(meshId, entry.id);
         return entry;
       });
@@ -35228,6 +35268,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         init_logger();
         init_mesh_ledger();
         init_mesh_delivery_policy();
+        init_mesh_task_inflight();
         ACTIVE_MESH_QUEUE_STATUSES = ["pending", "assigned"];
         HISTORICAL_MESH_QUEUE_STATUSES = ["completed", "failed", "cancelled"];
         MESH_TASK_MODES = ["code_change", "validation", "live_debug_readonly", "launch_app", "convergence"];
@@ -37293,7 +37334,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
               timestamp: entry.timestamp,
               ...entry.sessionId ? { sessionId: entry.sessionId } : {},
               bootstrap: readRecord3(validationSummary?.bootstrap),
-              validation: validationSummary ? Object.fromEntries(Object.entries(validationSummary).filter(([key]) => key !== "bootstrap")) : null,
+              validation: validationSummary ? Object.fromEntries(Object.entries(validationSummary).filter(([key2]) => key2 !== "bootstrap")) : null,
               checkpoint: readRecord3(result?.checkpoint),
               worker: null,
               ...readRecord3(payload.finalBranchConvergenceState) ?? readRecord3(result?.finalBranchConvergenceState) ? { finalBranchConvergenceState: readRecord3(payload.finalBranchConvergenceState) ?? readRecord3(result?.finalBranchConvergenceState) } : {},
@@ -37556,7 +37597,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       };
     }
     function renderMeshCoordinatorTemplate(template, values) {
-      return template.replace(/\{\{\s*(meshId|workspace|serverName|adhdevMcpCommand|adhdevMcpArgs)\s*\}\}/g, (_, key) => values[key] || "");
+      return template.replace(/\{\{\s*(meshId|workspace|serverName|adhdevMcpCommand|adhdevMcpArgs)\s*\}\}/g, (_, key2) => values[key2] || "");
     }
     function replaceLegacyCliCommandMcpArgs(command, args) {
       return command.replace(
@@ -37565,9 +37606,9 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       );
     }
     function resolveHermesCoordinatorHome(meshId, workspace) {
-      const key = `${meshId || "mesh"}
+      const key2 = `${meshId || "mesh"}
 ${(0, import_node_path.resolve)(workspace || os42.tmpdir())}`;
-      const hash2 = shortHash(key);
+      const hash2 = shortHash(key2);
       return (0, import_node_path.join)(os42.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash2}`);
     }
     function resolveMcpConfigPath(configPath, workspace) {
@@ -38043,9 +38084,9 @@ ${rendered}`, "utf-8");
       const seen = /* @__PURE__ */ new Set();
       const suggestions = [];
       for (const entry of [...collectProjectContextSuggestions(mesh), ...collectPackageScriptSuggestions(workspace)]) {
-        const key = `${entry.command} ${(entry.args || []).join(" ")}`.trim();
-        if (seen.has(key)) continue;
-        seen.add(key);
+        const key2 = `${entry.command} ${(entry.args || []).join(" ")}`.trim();
+        if (seen.has(key2)) continue;
+        seen.add(key2);
         suggestions.push(entry);
       }
       return {
@@ -41563,6 +41604,9 @@ Next step: ${nextStep}`;
         "use strict";
       }
     });
+    function localCoordinatorDaemonId() {
+      return canonicalDaemonId(readNonEmptyString2(loadConfig2().machineId));
+    }
     function __resetIdleAutoFastForwardForTests() {
       idleAutoFastForwardLastAttempt.clear();
     }
@@ -41648,6 +41692,7 @@ Next step: ${nextStep}`;
         if (timer) clearTimeout(timer);
         LOG2.error("MeshQueue", `Failed to dispatch task via ${ctx.transport} to node ${ctx.nodeId}: ${e?.message}`);
         updateSessionDeliveryStatus(delivery.id, "failed", { lastError: e?.message, incrementAttempt: true });
+        endTaskDispatchInFlight(ctx.meshId, ctx.task.id);
         updateTaskStatus(ctx.meshId, ctx.task.id, "pending");
         try {
           appendLedgerEntry(ctx.meshId, {
@@ -41721,10 +41766,11 @@ Next step: ${nextStep}`;
         return false;
       }
       LOG2.info("MeshQueue", `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
+      beginTaskDispatchInFlight(meshId, task.id);
       if (node?.daemonId && components.dispatchMeshCommand) {
         const isLocalNode = components.cliManager.adapters.has(sessionId);
         if (!isLocalNode) {
-          const localDaemonIdForDispatch = readNonEmptyString2(loadConfig2().machineId) || void 0;
+          const localDaemonIdForDispatch = localCoordinatorDaemonId();
           const sourceCoordinatorSessionId = readNonEmptyString2(task.sourceCoordinatorSessionId) || void 0;
           const dispatchMeshCommand = components.dispatchMeshCommand;
           const remoteDaemonId = node.daemonId;
@@ -41763,7 +41809,7 @@ Next step: ${nextStep}`;
       try {
         const inst = components.instanceManager.getInstance(sessionId);
         if (inst && typeof inst.updateSettings === "function") {
-          const localDaemonId = readNonEmptyString2(loadConfig2().machineId);
+          const localDaemonId = localCoordinatorDaemonId();
           const localSourceCoordinatorSessionId = readNonEmptyString2(task.sourceCoordinatorSessionId);
           inst.updateSettings({
             meshNodeFor: meshId,
@@ -41788,7 +41834,7 @@ Next step: ${nextStep}`;
             meshId,
             nodeId,
             taskId: task.id,
-            ...readNonEmptyString2(loadConfig2().machineId) ? { coordinatorDaemonId: readNonEmptyString2(loadConfig2().machineId) } : {},
+            ...localCoordinatorDaemonId() ? { coordinatorDaemonId: localCoordinatorDaemonId() } : {},
             ...readNonEmptyString2(task.sourceCoordinatorSessionId) ? { coordinatorSessionId: readNonEmptyString2(task.sourceCoordinatorSessionId) } : {}
           }
         }),
@@ -41800,7 +41846,7 @@ Next step: ${nextStep}`;
           task,
           transport: "local",
           ...readNonEmptyString2(task.sourceCoordinatorSessionId) ? { sourceCoordinatorSessionId: readNonEmptyString2(task.sourceCoordinatorSessionId) } : {},
-          ...readNonEmptyString2(loadConfig2().machineId) ? { sourceCoordinatorDaemonId: readNonEmptyString2(loadConfig2().machineId) } : {}
+          ...localCoordinatorDaemonId() ? { sourceCoordinatorDaemonId: localCoordinatorDaemonId() } : {}
         }
       );
       return true;
@@ -41882,8 +41928,8 @@ Next step: ${nextStep}`;
     }
     function sweepExpiredCooldowns() {
       const now = Date.now();
-      for (const [key, until] of autoLaunchCooldownUntil) {
-        if (now >= until) autoLaunchCooldownUntil.delete(key);
+      for (const [key2, until] of autoLaunchCooldownUntil) {
+        if (now >= until) autoLaunchCooldownUntil.delete(key2);
       }
     }
     function normalizeProviderPriority(policy) {
@@ -41929,7 +41975,7 @@ Next step: ${nextStep}`;
         const settings = state.settings || {};
         if (readNonEmptyString2(settings.meshNodeFor) !== meshId) return false;
         const instNodeId = readNonEmptyString2(settings.meshNodeId) || readNonEmptyString2(settings.nodeId);
-        if (instNodeId !== nodeId) return false;
+        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
         const sessionId = readNonEmptyString2(state.instanceId);
         if (currentSessionId && sessionId === currentSessionId && isIdleSessionState(state)) return false;
         return sessionStateLooksActive(state);
@@ -41961,7 +42007,7 @@ Next step: ${nextStep}`;
       const daemonId = readNonEmptyString2(node?.daemonId);
       if (!daemonId) return { mode: "skip", reason: "remote_auto_launch_unsupported" };
       if (!components.dispatchMeshCommand) return { mode: "skip", reason: "remote_auto_launch_unsupported" };
-      const coordinatorDaemonId = readNonEmptyString2(loadConfig2().machineId);
+      const coordinatorDaemonId = localCoordinatorDaemonId();
       if (!coordinatorDaemonId) return { mode: "skip", reason: "remote_auto_launch_no_coordinator_daemon_id" };
       return { mode: "remote", daemonId, coordinatorDaemonId };
     }
@@ -41972,7 +42018,7 @@ Next step: ${nextStep}`;
       return getQueue(meshId, { status: ["assigned"] }).filter(isTaskReadonly).length;
     }
     function nodeHasActiveAssignment(meshId, nodeId) {
-      return getQueue(meshId, { status: ["assigned"] }).some((task) => task.assignedNodeId === nodeId);
+      return getQueue(meshId, { status: ["assigned"] }).some((task) => daemonIdsEquivalent(task.assignedNodeId, nodeId));
     }
     function nodeActiveLoad(meshId, nodeId) {
       return MeshRuntimeStore.getInstance().nodeActiveAssignmentCount(meshId, nodeId);
@@ -42002,7 +42048,7 @@ Next step: ${nextStep}`;
       });
     }
     function activeProviderAssignedCount(meshId, nodeId, providerType) {
-      return getQueue(meshId, { status: ["assigned"] }).filter((task) => task.assignedNodeId === nodeId && task.assignedProviderType === providerType).length;
+      return getQueue(meshId, { status: ["assigned"] }).filter((task) => daemonIdsEquivalent(task.assignedNodeId, nodeId) && task.assignedProviderType === providerType).length;
     }
     function sessionHasActiveAssignment(meshId, sessionId) {
       if (getQueue(meshId, { status: ["assigned"] }).some((task) => task.assignedSessionId === sessionId)) {
@@ -42021,7 +42067,7 @@ Next step: ${nextStep}`;
         const settings = state.settings || {};
         if (readNonEmptyString2(settings.meshNodeFor) !== meshId) return false;
         const instNodeId = readNonEmptyString2(settings.meshNodeId) || readNonEmptyString2(settings.nodeId);
-        if (instNodeId !== nodeId) return false;
+        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
         const status = readNonEmptyString2(state.status).toLowerCase();
         return !isTerminalSessionStatus(status);
       }).length;
@@ -42555,6 +42601,7 @@ Next step: ${nextStep}`;
         init_mesh_events_utils();
         init_mesh_events_pending();
         init_worktree_bootstrap_config();
+        init_mesh_task_inflight();
         IDLE_AUTO_FAST_FORWARD_THROTTLE_MS = 30 * 60 * 1e3;
         idleAutoFastForwardLastAttempt = /* @__PURE__ */ new Map();
         DISPATCH_CONFIRM_TIMEOUT_MS = 12e4;
@@ -42653,8 +42700,8 @@ Next step: ${nextStep}`;
       if (last !== void 0 && now - last < UNROUTABLE_DIAGNOSTIC_DEDUP_MS) return false;
       recentUnroutableDiagnostics.set(dedupKey, now);
       if (recentUnroutableDiagnostics.size > 256) {
-        for (const [key, ts2] of recentUnroutableDiagnostics) {
-          if (now - ts2 >= UNROUTABLE_DIAGNOSTIC_DEDUP_MS) recentUnroutableDiagnostics.delete(key);
+        for (const [key2, ts2] of recentUnroutableDiagnostics) {
+          if (now - ts2 >= UNROUTABLE_DIAGNOSTIC_DEDUP_MS) recentUnroutableDiagnostics.delete(key2);
         }
       }
       try {
@@ -42916,9 +42963,9 @@ Next step: ${nextStep}`;
         for (const line of stdout.split("\n")) {
           const m = line.match(/^\s*Pages\s+([^:]+):\s+([\d,]+)\s*\.?/);
           if (!m) continue;
-          const key = m[1].trim().toLowerCase().replace(/\s+/g, "_");
+          const key2 = m[1].trim().toLowerCase().replace(/\s+/g, "_");
           const n = parseInt(m[2].replace(/,/g, ""), 10);
-          if (!Number.isNaN(n)) counts[key] = n;
+          if (!Number.isNaN(n)) counts[key2] = n;
         }
         const free = counts["free"] ?? 0;
         const inactive = counts["inactive"] ?? 0;
@@ -43149,7 +43196,7 @@ Next step: ${nextStep}`;
       if (Array.isArray(value)) return value.map((item) => trimStructuredStrings(item, maxChars));
       if (!value || typeof value !== "object") return value;
       return Object.fromEntries(
-        Object.entries(value).map(([key, nested]) => [key, trimStructuredStrings(nested, maxChars)])
+        Object.entries(value).map(([key2, nested]) => [key2, trimStructuredStrings(nested, maxChars)])
       );
     }
     function estimateBytes(value) {
@@ -43738,9 +43785,9 @@ Next step: ${nextStep}`;
     function readStringField(value) {
       return typeof value === "string" ? value.trim().toLowerCase() : "";
     }
-    function readRecordField(message, meta3, key) {
+    function readRecordField(message, meta3, key2) {
       const record2 = message;
-      return record2[key] ?? meta3?.[key];
+      return record2[key2] ?? meta3?.[key2];
     }
     function readVisibilityField(message, meta3) {
       return readStringField(readRecordField(message, meta3, "visibility"));
@@ -43751,7 +43798,7 @@ Next step: ${nextStep}`;
     }
     function hasBooleanMarker(message, meta3, keys) {
       const record2 = message;
-      return keys.some((key) => record2[key] === true || meta3?.[key] === true);
+      return keys.some((key2) => record2[key2] === true || meta3?.[key2] === true);
     }
     function isActivityKind(kind) {
       return kind === "thought" || kind === "tool" || kind === "terminal";
@@ -43955,9 +44002,9 @@ Next step: ${nextStep}`;
       const values = {};
       const explicit = data.controlValues;
       if (explicit && typeof explicit === "object") {
-        for (const [key, value] of Object.entries(explicit)) {
+        for (const [key2, value] of Object.entries(explicit)) {
           if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-            values[key] = value;
+            values[key2] = value;
           }
         }
       }
@@ -44416,26 +44463,26 @@ ${cleanBody}`;
       if (!workspace) return void 0;
       return options.getGitSummaryForWorkspace?.(workspace) || void 0;
     }
-    function findCdpManager(cdpManagers, key) {
-      const exact = cdpManagers.get(key);
+    function findCdpManager(cdpManagers, key2) {
+      const exact = cdpManagers.get(key2);
       if (exact) return exact.isConnected ? exact : null;
-      const prefix = key + "_";
+      const prefix = key2 + "_";
       const matches = [...cdpManagers.entries()].filter(([k, m]) => m.isConnected && k.startsWith(prefix));
       if (matches.length === 1) return matches[0][1];
       return null;
     }
-    function hasCdpManager(cdpManagers, key) {
-      if (cdpManagers.has(key)) return true;
-      const prefix = key + "_";
+    function hasCdpManager(cdpManagers, key2) {
+      if (cdpManagers.has(key2)) return true;
+      const prefix = key2 + "_";
       for (const k of cdpManagers.keys()) {
         if (k.startsWith(prefix)) return true;
       }
       return false;
     }
-    function isCdpConnected(cdpManagers, key) {
-      const exact = cdpManagers.get(key);
+    function isCdpConnected(cdpManagers, key2) {
+      const exact = cdpManagers.get(key2);
       if (exact?.isConnected) return true;
-      const prefix = key + "_";
+      const prefix = key2 + "_";
       for (const [k, m] of cdpManagers.entries()) {
         if (m.isConnected && k.startsWith(prefix)) return true;
       }
@@ -46333,9 +46380,9 @@ ${cleanBody}`;
       for (const event of pending) {
         if (!shouldForceInjectMeshEvent(event.event)) continue;
         const fingerprint = buildPendingEventFingerprint(event);
-        const key = `${meshId}::${fingerprint || `${event.event}::${event.nodeId || ""}::${event.queuedAt}`}`;
-        if (heldEventLedgerRecorded.has(key)) continue;
-        heldEventLedgerRecorded.add(key);
+        const key2 = `${meshId}::${fingerprint || `${event.event}::${event.nodeId || ""}::${event.queuedAt}`}`;
+        if (heldEventLedgerRecorded.has(key2)) continue;
+        heldEventLedgerRecorded.add(key2);
         const finalSummary = readMeshCompletionSummary(event.metadataEvent);
         try {
           appendLedgerEntry(meshId, {
@@ -46356,7 +46403,7 @@ ${cleanBody}`;
           });
           LOG2.info("MeshReconcile", `Ledger-recorded held ${event.event} for mesh ${meshId} (reason ${reason}) \u2014 recoverable from ledger`);
         } catch (e) {
-          heldEventLedgerRecorded.delete(key);
+          heldEventLedgerRecorded.delete(key2);
           LOG2.warn("MeshReconcile", `Failed to ledger-record held ${event.event} for mesh ${meshId}: ${e?.message || e}`);
         }
       }
@@ -46821,9 +46868,9 @@ ${cleanBody}`;
       const activeTaskKeys = new Set(
         dispatches.map((d) => readNonEmptyString2(d.taskId)).filter(Boolean).map((taskId) => inFlightSynthKey(mesh.id, taskId))
       );
-      for (const key of inFlightAckedHoldState.keys()) {
-        if (key.startsWith(`${mesh.id}::`) && !activeTaskKeys.has(key)) {
-          inFlightAckedHoldState.delete(key);
+      for (const key2 of inFlightAckedHoldState.keys()) {
+        if (key2.startsWith(`${mesh.id}::`) && !activeTaskKeys.has(key2)) {
+          inFlightAckedHoldState.delete(key2);
         }
       }
       const dispatchMeshCommand = components.dispatchMeshCommand;
@@ -48411,8 +48458,8 @@ ${cleanBody}`;
             label += " " + next.trim();
             j += 1;
           }
-          const key = keyTemplate.replace(/\{index\}/g, String(idx));
-          buttons.push({ index: idx, label, key, current });
+          const key2 = keyTemplate.replace(/\{index\}/g, String(idx));
+          buttons.push({ index: idx, label, key: key2, current });
           i = j - 1;
         }
       } else {
@@ -48422,8 +48469,8 @@ ${cleanBody}`;
           const idx = Number(m[1]);
           const label = String(m[2] ?? "").trim();
           if (!Number.isFinite(idx) || idx <= 0 || !label) continue;
-          const key = keyTemplate.replace(/\{index\}/g, String(idx));
-          buttons.push({ index: idx, label, key, current: hasCursorMarker(m[0]) });
+          const key2 = keyTemplate.replace(/\{index\}/g, String(idx));
+          buttons.push({ index: idx, label, key: key2, current: hasCursorMarker(m[0]) });
         }
       }
       const block2 = lastContiguousNumberedBlock(buttons);
@@ -48501,12 +48548,12 @@ ${cleanBody}`;
         return { kind: "elapsed", result, detail: `elapsed ${age}ms / ${cond.elapsed_ms}ms`, remainingMs };
       }
       if (isStable(cond)) {
-        const key = regionKey(cond.cursor_above);
-        const lastChanged = clock.regionLastChangedAt.get(key) ?? clock.stateEnteredAt;
+        const key2 = regionKey(cond.cursor_above);
+        const lastChanged = clock.regionLastChangedAt.get(key2) ?? clock.stateEnteredAt;
         const stableFor = clock.now - lastChanged;
         const result = stableFor >= cond.stable_ms;
         const remainingMs = result ? 0 : cond.stable_ms - stableFor;
-        const where = key === WHOLE_SCREEN ? "screen" : `cursor_above=${cond.cursor_above}`;
+        const where = key2 === WHOLE_SCREEN ? "screen" : `cursor_above=${cond.cursor_above}`;
         return { kind: "stable", result, detail: `stable ${where} ${stableFor}ms / ${cond.stable_ms}ms`, remainingMs };
       }
       if (isRegex(cond) || isChanged(cond)) {
@@ -52441,16 +52488,16 @@ ${lastSnapshot}`;
     }
     function buildFsShim() {
       const shim = {};
-      for (const key of FS_READ_ONLY_MEMBERS) {
-        if (key === "promises") continue;
-        const real = nodeFs[key];
-        if (real !== void 0) shim[key] = real;
+      for (const key2 of FS_READ_ONLY_MEMBERS) {
+        if (key2 === "promises") continue;
+        const real = nodeFs[key2];
+        if (real !== void 0) shim[key2] = real;
       }
       const realPromises = nodeFs.promises || {};
       const promisesShim = {};
-      for (const key of FS_PROMISES_READ_ONLY_MEMBERS) {
-        const real = realPromises[key];
-        if (real !== void 0) promisesShim[key] = real;
+      for (const key2 of FS_PROMISES_READ_ONLY_MEMBERS) {
+        const real = realPromises[key2];
+        if (real !== void 0) promisesShim[key2] = real;
       }
       shim.promises = promisesShim;
       return shim;
@@ -52533,10 +52580,10 @@ ${lastSnapshot}`;
     function buildProcessShim() {
       const real = globalThis.process;
       const shim = /* @__PURE__ */ Object.create(null);
-      for (const key of Object.keys(real)) {
-        if (DANGEROUS_PROCESS_METHODS.has(String(key))) continue;
+      for (const key2 of Object.keys(real)) {
+        if (DANGEROUS_PROCESS_METHODS.has(String(key2))) continue;
         try {
-          shim[key] = real[key];
+          shim[key2] = real[key2];
         } catch {
         }
       }
@@ -52872,6 +52919,7 @@ ${lastSnapshot}`;
       buildToolChatMessage: () => buildToolChatMessage,
       buildUserChatMessage: () => buildUserChatMessage,
       cancelTask: () => cancelTask,
+      canonicalDaemonId: () => canonicalDaemonId,
       claimNextTask: () => claimNextTask,
       classifyChatMessageVisibility: () => classifyChatMessageVisibility,
       classifyHotChatSessionsForSubscriptionFlush: () => classifyHotChatSessionsForSubscriptionFlush2,
@@ -53724,10 +53772,10 @@ ${lastSnapshot}`;
         const compactSummary = createGitCompactSummary(status, diffSummary);
         const timestamp = this.now();
         const seq = ++this.seq;
-        const key = this.keyForWorkspace(normalized.workspace);
+        const key2 = this.keyForWorkspace(normalized.workspace);
         const update = {
           topic: "workspace.git",
-          key,
+          key: key2,
           workspace: normalized.workspace,
           status,
           diffSummary,
@@ -53735,7 +53783,7 @@ ${lastSnapshot}`;
           timestamp
         };
         const cacheEntry = {
-          key,
+          key: key2,
           workspace: normalized.workspace,
           status,
           diffSummary,
@@ -53877,11 +53925,11 @@ ${lastSnapshot}`;
       }
       return { path: args.path.trim() };
     }
-    function validateSnapshotId(args, key) {
-      if (typeof args?.[key] !== "string" || !args[key].trim()) {
-        return failure("invalid_args", `${key} must be a non-empty string`);
+    function validateSnapshotId(args, key2) {
+      if (typeof args?.[key2] !== "string" || !args[key2].trim()) {
+        return failure("invalid_args", `${key2} must be a non-empty string`);
       }
-      return args[key].trim();
+      return args[key2].trim();
     }
     function parseSnapshotReason(args) {
       if (args?.reason === void 0 || args?.reason === null || args?.reason === "") {
@@ -56249,10 +56297,10 @@ ${lastSnapshot}`;
         return events;
       }
       /** Cooldown check — prevent sending the same notification too frequently */
-      shouldAlert(key, now) {
-        const last = this.lastAlertTime.get(key) || 0;
+      shouldAlert(key2, now) {
+        const last = this.lastAlertTime.get(key2) || 0;
         if (now - last > this.config.alertCooldownSec * 1e3) {
-          this.lastAlertTime.set(key, now);
+          this.lastAlertTime.set(key2, now);
           return true;
         }
         return false;
@@ -56296,16 +56344,16 @@ ${lastSnapshot}`;
     var savedHistoryRollupInFlight = /* @__PURE__ */ new Set();
     var BOUNDED_TAIL_CACHE_MAX_ENTRIES = 64;
     var boundedTailReadCache = /* @__PURE__ */ new Map();
-    function readBoundedTailCache(key, signature) {
-      const cached3 = boundedTailReadCache.get(key);
+    function readBoundedTailCache(key2, signature) {
+      const cached3 = boundedTailReadCache.get(key2);
       if (!cached3 || cached3.signature !== signature) return null;
-      boundedTailReadCache.delete(key);
-      boundedTailReadCache.set(key, cached3);
+      boundedTailReadCache.delete(key2);
+      boundedTailReadCache.set(key2, cached3);
       return cached3.result;
     }
-    function writeBoundedTailCache(key, signature, result) {
-      boundedTailReadCache.delete(key);
-      boundedTailReadCache.set(key, { signature, result });
+    function writeBoundedTailCache(key2, signature, result) {
+      boundedTailReadCache.delete(key2);
+      boundedTailReadCache.set(key2, { signature, result });
       while (boundedTailReadCache.size > BOUNDED_TAIL_CACHE_MAX_ENTRIES) {
         const oldest = boundedTailReadCache.keys().next().value;
         if (oldest === void 0) break;
@@ -56741,21 +56789,21 @@ ${lastSnapshot}`;
       return shouldScheduleSavedHistoryRollup(size);
     }
     function scheduleSavedHistoryRollup(agentType, historySessionId) {
-      const key = `${agentType}:${historySessionId}`;
-      if (!historySessionId || savedHistoryRollupInFlight.has(key)) return;
-      savedHistoryRollupInFlight.add(key);
+      const key2 = `${agentType}:${historySessionId}`;
+      if (!historySessionId || savedHistoryRollupInFlight.has(key2)) return;
+      savedHistoryRollupInFlight.add(key2);
       setTimeout(() => {
         try {
           new ChatHistoryWriter().compactHistorySession(agentType, historySessionId);
         } finally {
-          savedHistoryRollupInFlight.delete(key);
+          savedHistoryRollupInFlight.delete(key2);
         }
       }, 0);
     }
     function scheduleSavedHistoryBackgroundRefresh(agentType, dir) {
-      const key = `${agentType}:${dir}`;
-      if (savedHistoryBackgroundRefresh.has(key)) return;
-      savedHistoryBackgroundRefresh.add(key);
+      const key2 = `${agentType}:${dir}`;
+      if (savedHistoryBackgroundRefresh.has(key2)) return;
+      savedHistoryBackgroundRefresh.add(key2);
       setTimeout(() => {
         try {
           if (!fs6.existsSync(dir)) return;
@@ -56775,7 +56823,7 @@ ${lastSnapshot}`;
           }
         } catch {
         } finally {
-          savedHistoryBackgroundRefresh.delete(key);
+          savedHistoryBackgroundRefresh.delete(key2);
         }
       }, 0);
     }
@@ -57541,14 +57589,14 @@ ${lastSnapshot}`;
         return false;
       }
     }
-    function getNativeHistoryScriptName(canonicalHistory, key) {
-      const configured = canonicalHistory?.scripts?.[key];
+    function getNativeHistoryScriptName(canonicalHistory, key2) {
+      const configured = canonicalHistory?.scripts?.[key2];
       if (typeof configured === "string" && configured.trim()) return configured.trim();
-      return key === "readSession" ? "readNativeHistory" : "listNativeHistory";
+      return key2 === "readSession" ? "readNativeHistory" : "listNativeHistory";
     }
-    function getProviderNativeHistoryScript(scripts, canonicalHistory, key) {
+    function getProviderNativeHistoryScript(scripts, canonicalHistory, key2) {
       if (!canonicalHistory?.scripts) return null;
-      const fn = scripts?.[getNativeHistoryScriptName(canonicalHistory, key)];
+      const fn = scripts?.[getNativeHistoryScriptName(canonicalHistory, key2)];
       return typeof fn === "function" ? fn : null;
     }
     function normalizeProviderNativeHistoryRecords(agentType, historySessionId, records) {
@@ -58272,11 +58320,11 @@ ${effect.notification.body || ""}`.trim();
         throw new Error(`${source}: controlValues must be an object when provided`);
       }
       const normalized = {};
-      for (const [key, value] of Object.entries(controlValues)) {
+      for (const [key2, value] of Object.entries(controlValues)) {
         if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
-          throw new Error(`${source}: controlValues.${key} must be string, number, or boolean`);
+          throw new Error(`${source}: controlValues.${key2} must be string, number, or boolean`);
         }
-        normalized[key] = value;
+        normalized[key2] = value;
       }
       return normalized;
     }
@@ -59023,7 +59071,7 @@ ${effect.notification.body || ""}`.trim();
           for (const [ide, ports] of Object.entries(portMap)) {
             const primaryPort = ports[0];
             const alreadyConnected = [...this.ctx.cdpManagers.entries()].some(
-              ([key, m]) => m.isConnected && (key === ide || key.startsWith(ide + "_"))
+              ([key2, m]) => m.isConnected && (key2 === ide || key2.startsWith(ide + "_"))
             );
             if (alreadyConnected) continue;
             if (this.opts.multiWindow) {
@@ -59195,8 +59243,8 @@ ${effect.notification.body || ""}`.trim();
         for (let i = 0; i < targets.length; i++) {
           const target = targets[i];
           let alreadyTracked = false;
-          for (const [key, m] of cdpManagers.entries()) {
-            if ((key === ide || key.startsWith(`${ide}_`)) && m.targetId === target.id) {
+          for (const [key2, m] of cdpManagers.entries()) {
+            if ((key2 === ide || key2.startsWith(`${ide}_`)) && m.targetId === target.id) {
               alreadyTracked = true;
               break;
             }
@@ -59228,29 +59276,29 @@ ${effect.notification.body || ""}`.trim();
       async pruneStaleManagers(port, ide, targets) {
         const trackedTargetIds = new Set(targets.map((target) => target.id));
         const removals = [];
-        for (const [key, manager] of this.config.cdpManagers.entries()) {
-          if (!(key === ide || key.startsWith(`${ide}_`))) continue;
+        for (const [key2, manager] of this.config.cdpManagers.entries()) {
+          if (!(key2 === ide || key2.startsWith(`${ide}_`))) continue;
           if (manager.getPort() !== port) continue;
           if (targets.length === 0) {
-            removals.push({ key, manager, reason: "ide_closed" });
+            removals.push({ key: key2, manager, reason: "ide_closed" });
             continue;
           }
           if (manager.targetId && !trackedTargetIds.has(manager.targetId)) {
-            removals.push({ key, manager, reason: "target_closed" });
+            removals.push({ key: key2, manager, reason: "target_closed" });
             continue;
           }
-          if (key === ide && !manager.targetId && targets.length > 1) {
-            removals.push({ key, manager, reason: "target_rekeyed" });
+          if (key2 === ide && !manager.targetId && targets.length > 1) {
+            removals.push({ key: key2, manager, reason: "target_rekeyed" });
           }
         }
-        for (const { key, manager, reason } of removals) {
+        for (const { key: key2, manager, reason } of removals) {
           try {
             manager.disconnect();
           } catch {
           }
-          this.config.cdpManagers.delete(key);
-          LOG2.info("IDE", `Detached window: ${key} (${reason})`);
-          await this.config.onDisconnected?.(ide, manager, key, reason);
+          this.config.cdpManagers.delete(key2);
+          LOG2.info("IDE", `Detached window: ${key2} (${reason})`);
+          await this.config.onDisconnected?.(ide, manager, key2, reason);
         }
       }
       // ─── Periodic scanning ───
@@ -59554,7 +59602,7 @@ ${effect.notification.body || ""}`.trim();
         if (Array.isArray(value)) return value.map((entry) => sanitizeTraceValue(entry, traceContent));
         if (value && typeof value === "object") {
           return Object.fromEntries(
-            Object.entries(value).map(([key, nested]) => [key, sanitizeTraceValue(nested, traceContent)])
+            Object.entries(value).map(([key2, nested]) => [key2, sanitizeTraceValue(nested, traceContent)])
           );
         }
         return value;
@@ -59563,7 +59611,7 @@ ${effect.notification.body || ""}`.trim();
       if (Array.isArray(value)) return value.map((entry) => sanitizeTraceValue(entry, traceContent));
       if (value && typeof value === "object") {
         return Object.fromEntries(
-          Object.entries(value).map(([key, nested]) => [key, sanitizeTraceValue(nested, traceContent)])
+          Object.entries(value).map(([key2, nested]) => [key2, sanitizeTraceValue(nested, traceContent)])
         );
       }
       return value;
@@ -59867,8 +59915,8 @@ ${effect.notification.body || ""}`.trim();
     }
     function isSupersetOf(candidate, required2) {
       if (required2.size === 0) return true;
-      for (const key of required2) {
-        if (!candidate.has(key)) return false;
+      for (const key2 of required2) {
+        if (!candidate.has(key2)) return false;
       }
       return true;
     }
@@ -59879,17 +59927,17 @@ ${effect.notification.body || ""}`.trim();
     var ChatSourceRegistry = class {
       records = /* @__PURE__ */ new Map();
       /** Snapshot of current state for diagnostics. Does not mutate. */
-      getState(key) {
-        return this.records.get(key)?.state ?? INITIAL_CHAT_SOURCE_STATE;
+      getState(key2) {
+        return this.records.get(key2)?.state ?? INITIAL_CHAT_SOURCE_STATE;
       }
       /** Recent transitions, newest last. Empty array when nothing has happened. */
-      getTransitions(key) {
-        return this.records.get(key)?.transitions ?? [];
+      getTransitions(key2) {
+        return this.records.get(key2)?.transitions ?? [];
       }
       /** Drop a session. Caller should invoke this when the session is destroyed
        *  to avoid unbounded growth across long-lived daemons. */
-      clear(key) {
-        this.records.delete(key);
+      clear(key2) {
+        this.records.delete(key2);
       }
       /** Drop all sessions. Test helper. */
       clearAll() {
@@ -59901,15 +59949,15 @@ ${effect.notification.body || ""}`.trim();
        * under `key`; callers may treat the decision as authoritative without
        * re-reading.
        */
-      observe(key, observation, at = Date.now()) {
-        const prev = this.records.get(key);
+      observe(key2, observation, at = Date.now()) {
+        const prev = this.records.get(key2);
         const prevState = prev?.state ?? INITIAL_CHAT_SOURCE_STATE;
         const prevLockedSince = prev?.lockedSince;
         const result = transitionChatSourceState(prevState, observation, at, prevLockedSince);
         const transitions = prev?.transitions ?? [];
         const nextTransitions = appendTransition(transitions, result.transition);
         const lockedSince = result.lockState.lockedSince;
-        this.records.set(key, {
+        this.records.set(key2, {
           state: result.next,
           lockedSince,
           transitions: nextTransitions
@@ -60590,8 +60638,8 @@ ${effect.notification.body || ""}`.trim();
       });
       return { ...history, lookup: "workspace" };
     }
-    function shouldPreserveReadChatPayloadField(key) {
-      return key === "messageSource" || key === "transcriptProvenance";
+    function shouldPreserveReadChatPayloadField(key2) {
+      return key2 === "messageSource" || key2 === "transcriptProvenance";
     }
     function updateMessageSourceReturnedCount(value, returnedMessageCount) {
       if (!value || typeof value !== "object" || Array.isArray(value)) return value;
@@ -60761,7 +60809,7 @@ ${effect.notification.body || ""}`.trim();
       const visibleMessages = includeActivity ? filteredMessages.filter((m) => isUserFacingChatMessage(m) || isActivityChatMessage(m)) : filterUserFacingChatMessages(filteredMessages);
       const sync = buildFullTail(visibleMessages, normalizeReadChatTailLimit(args));
       const hiddenMsgCount = Math.max(0, messages.length - visibleMessages.length);
-      const preservedPayloadFields = Object.fromEntries(Object.entries(payload).filter(([key]) => shouldPreserveReadChatPayloadField(key)));
+      const preservedPayloadFields = Object.fromEntries(Object.entries(payload).filter(([key2]) => shouldPreserveReadChatPayloadField(key2)));
       if (preservedPayloadFields.messageSource) {
         preservedPayloadFields.messageSource = updateMessageSourceReturnedCount(preservedPayloadFields.messageSource, sync.messages.length);
       }
@@ -61511,8 +61559,8 @@ ${effect.notification.body || ""}`.trim();
       const record2 = value;
       const result = {};
       const entries = Object.entries(record2).slice(0, normalizedOptions.maxObjectKeys);
-      for (const [key, item] of entries) {
-        result[key] = sanitizeDebugBundleValue(item, normalizedOptions, depth + 1, key);
+      for (const [key2, item] of entries) {
+        result[key2] = sanitizeDebugBundleValue(item, normalizedOptions, depth + 1, key2);
       }
       const remaining = Object.keys(record2).length - entries.length;
       if (remaining > 0) result.__truncatedKeys = remaining;
@@ -61836,14 +61884,14 @@ ${effect.notification.body || ""}`.trim();
       if (typeof script !== "function") return null;
       return script(text);
     }
-    function isRecentDuplicateSend(key) {
+    function isRecentDuplicateSend(key2) {
       const now = Date.now();
       for (const [candidate, ts2] of recentSendByTarget.entries()) {
         if (now - ts2 > RECENT_SEND_WINDOW_MS) recentSendByTarget.delete(candidate);
       }
-      const previous = recentSendByTarget.get(key);
+      const previous = recentSendByTarget.get(key2);
       if (previous && now - previous <= RECENT_SEND_WINDOW_MS) return true;
-      recentSendByTarget.set(key, now);
+      recentSendByTarget.set(key2, now);
       return false;
     }
     function didProviderConfirmSend(result) {
@@ -62704,23 +62752,23 @@ ${effect.notification.body || ""}`.trim();
       try {
         switch (action) {
           case "input_key": {
-            const { type: evType, key, code, text, unmodifiedText, modifiers } = params;
+            const { type: evType, key: key2, code, text, unmodifiedText, modifiers } = params;
             const mod = typeof modifiers === "number" ? modifiers : 0;
-            const vk = KEY_TO_VK[key] || (key.length === 1 ? key.charCodeAt(0) : 0);
+            const vk = KEY_TO_VK[key2] || (key2.length === 1 ? key2.charCodeAt(0) : 0);
             if (evType === "char") {
               await h.getCdp().send("Input.dispatchKeyEvent", {
                 type: "char",
-                key,
+                key: key2,
                 code,
-                text: text || key,
-                unmodifiedText: unmodifiedText || text || key,
+                text: text || key2,
+                unmodifiedText: unmodifiedText || text || key2,
                 ...vk ? { windowsVirtualKeyCode: vk, nativeVirtualKeyCode: vk } : {},
                 ...mod ? { modifiers: mod } : {}
               });
             } else {
               await h.getCdp().send("Input.dispatchKeyEvent", {
                 type: "rawKeyDown",
-                key,
+                key: key2,
                 code,
                 ...text ? { text } : {},
                 ...vk ? { windowsVirtualKeyCode: vk, nativeVirtualKeyCode: vk } : {},
@@ -62728,7 +62776,7 @@ ${effect.notification.body || ""}`.trim();
               });
               await h.getCdp().send("Input.dispatchKeyEvent", {
                 type: "keyUp",
-                key,
+                key: key2,
                 code,
                 ...vk ? { windowsVirtualKeyCode: vk, nativeVirtualKeyCode: vk } : {},
                 ...mod ? { modifiers: mod } : {}
@@ -63119,21 +63167,21 @@ ${effect.notification.body || ""}`.trim();
     }
     async function handleSetProviderSetting(h, args) {
       const loader = h.ctx.providerLoader;
-      const { providerType, key, value } = args || {};
-      if (!providerType || !key || value === void 0) {
+      const { providerType, key: key2, value } = args || {};
+      if (!providerType || !key2 || value === void 0) {
         return { success: false, error: "providerType, key, and value are required" };
       }
-      const result = loader?.setSetting(providerType, key, value);
+      const result = loader?.setSetting(providerType, key2, value);
       if (result) {
         if (h.ctx.instanceManager) {
           const allSettings = loader?.getSettings(providerType) || {};
           const updated = h.ctx.instanceManager.updateInstanceSettings(providerType, allSettings);
-          LOG2.info("Command", `[set_provider_setting] ${providerType}.${key}=${JSON.stringify(value)} \u2192 ${updated} instance(s) updated`);
+          LOG2.info("Command", `[set_provider_setting] ${providerType}.${key2}=${JSON.stringify(value)} \u2192 ${updated} instance(s) updated`);
         }
-        await h.ctx.onProviderSettingChanged?.(providerType, key, value);
-        return { success: true, providerType, key, value };
+        await h.ctx.onProviderSettingChanged?.(providerType, key2, value);
+        return { success: true, providerType, key: key2, value };
       }
-      return { success: false, error: `Failed to set ${providerType}.${key} \u2014 invalid key, value, or not a public setting` };
+      return { success: false, error: `Failed to set ${providerType}.${key2} \u2014 invalid key, value, or not a public setting` };
     }
     function handleGetProviderSourceConfig(h, _args) {
       const loader = h.ctx.providerLoader;
@@ -63179,9 +63227,9 @@ ${effect.notification.body || ""}`.trim();
           normalizedArgs.mode = normalizedArgs.value;
         }
       }
-      for (const key of ["mode", "model", "message", "action", "button", "text", "sessionId", "value"]) {
-        if (key in normalizedArgs && !(key.toUpperCase() in normalizedArgs)) {
-          normalizedArgs[key.toUpperCase()] = normalizedArgs[key];
+      for (const key2 of ["mode", "model", "message", "action", "button", "text", "sessionId", "value"]) {
+        if (key2 in normalizedArgs && !(key2.toUpperCase() in normalizedArgs)) {
+          normalizedArgs[key2.toUpperCase()] = normalizedArgs[key2];
         }
       }
       return normalizedArgs;
@@ -63577,10 +63625,10 @@ ${effect.notification.body || ""}`.trim();
         "value"
       ];
       const entries = [];
-      for (const key of preferredKeys) {
-        if (!(key in args) || args[key] === void 0) continue;
-        const value = key === "text" || key === "message" ? `${String(args[key] || "").length} chars` : key === "data" ? `${String(args[key] || "").length} chars` : summarizeLogValue(args[key]);
-        entries.push(`${key}=${value}`);
+      for (const key2 of preferredKeys) {
+        if (!(key2 in args) || args[key2] === void 0) continue;
+        const value = key2 === "text" || key2 === "message" ? `${String(args[key2] || "").length} chars` : key2 === "data" ? `${String(args[key2] || "").length} chars` : summarizeLogValue(args[key2]);
+        entries.push(`${key2}=${value}`);
       }
       return entries.length ? entries.join(" ") : "{...}";
     }
@@ -63632,12 +63680,12 @@ ${effect.notification.body || ""}`.trim();
        * Get provider module — _currentProviderType (agentType priority) use.
        */
       getProvider(overrideType) {
-        const key = overrideType || this._currentRoute.providerType || this._currentRoute.session?.providerType || this._currentRoute.managerKey;
-        if (!key || !this._ctx.providerLoader) return void 0;
-        const result = this._ctx.providerLoader.resolve(key);
+        const key2 = overrideType || this._currentRoute.providerType || this._currentRoute.session?.providerType || this._currentRoute.managerKey;
+        if (!key2 || !this._ctx.providerLoader) return void 0;
+        const result = this._ctx.providerLoader.resolve(key2);
         if (result) return result;
-        const baseType = key.split("_")[0];
-        if (baseType !== key) return this._ctx.providerLoader.resolve(baseType);
+        const baseType = key2.split("_")[0];
+        if (baseType !== key2) return this._ctx.providerLoader.resolve(baseType);
         return void 0;
       }
       /** Get a provider script by name from ProviderLoader. */
@@ -63695,11 +63743,11 @@ ${effect.notification.body || ""}`.trim();
         return this._ctx.adapters.get(target) || null;
       }
       // ─── Private helpers ──────────────────────────────
-      inferProviderType(key) {
-        if (!key) return void 0;
-        const session = this._ctx.sessionRegistry?.get(key);
+      inferProviderType(key2) {
+        if (!key2) return void 0;
+        const session = this._ctx.sessionRegistry?.get(key2);
         if (session?.providerType) return session.providerType;
-        return key.split("_")[0];
+        return key2.split("_")[0];
       }
       resolveRoute(args) {
         const targetSessionId = typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : "";
@@ -65385,16 +65433,16 @@ ${formatManifestValidationIssues2(validation.issues)}`,
               const m = matchAppend || matchOverride;
               if (!m) continue;
               const isAppend = !!matchAppend;
-              const key = m[1];
+              const key2 = m[1];
               const full = path43.join(dir, name);
               let content = "";
               try {
                 content = fs38.readFileSync(full, "utf8");
               } catch {
               }
-              if (!entries[key]) entries[key] = { override: "", append: "" };
-              if (isAppend) entries[key].append = content;
-              else entries[key].override = content;
+              if (!entries[key2]) entries[key2] = { override: "", append: "" };
+              if (isAppend) entries[key2].append = content;
+              else entries[key2].override = content;
             }
           }
         } catch (error48) {
@@ -65406,14 +65454,14 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         const fs38 = await import("fs");
         const path43 = await import("path");
         const os30 = await import("os");
-        const key = typeof args?.key === "string" ? args.key.trim() : "";
+        const key2 = typeof args?.key === "string" ? args.key.trim() : "";
         const kind = args?.kind === "append" ? "append" : "override";
         const content = typeof args?.content === "string" ? args.content : "";
-        if (!key || !/^[a-zA-Z0-9_.-]+$/.test(key)) {
+        if (!key2 || !/^[a-zA-Z0-9_.-]+$/.test(key2)) {
           return { success: false, error: "key must match [a-zA-Z0-9_.-]+" };
         }
         const dir = path43.join(os30.homedir(), ".adhdev", "coordinator-prompts");
-        const filename = kind === "append" ? `${key}.append.md` : `${key}.md`;
+        const filename = kind === "append" ? `${key2}.append.md` : `${key2}.md`;
         const full = path43.join(dir, filename);
         try {
           fs38.mkdirSync(dir, { recursive: true });
@@ -65422,7 +65470,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           } else if (fs38.existsSync(full)) {
             fs38.unlinkSync(full);
           }
-          return { success: true, path: full, kind, key };
+          return { success: true, path: full, kind, key: key2 };
         } catch (error48) {
           return { success: false, error: error48?.message || String(error48) };
         }
@@ -66351,7 +66399,7 @@ ${body}
       {
         name: "key_value_secret",
         pattern: /\b([A-Z0-9_]*(?:SECRET|TOKEN|API[_-]?KEY|PASSWORD|PASSWD|PRIVATE[_-]?KEY|CREDENTIAL|CLIENT[_-]?SECRET)[A-Z0-9_]*)(\s*[:=]\s*)(["']?)([^\s"',;]+)\3/gi,
-        replace: (_m, key, delim, quote) => `${key}${delim}${quote}${MASK}${quote}`
+        replace: (_m, key2, delim, quote) => `${key2}${delim}${quote}${MASK}${quote}`
       },
       // Authorization: Bearer <token>
       {
@@ -66681,7 +66729,7 @@ ${body}
     }
     function applyPreLaunchTrust(trust, workingDir) {
       const settingsPath = expandHome2(trust.settings_path);
-      const key = trust.key;
+      const key2 = trust.key;
       const real = realWorkspacePath(workingDir);
       try {
         let parsed = {};
@@ -66694,18 +66742,18 @@ ${body}
             }
           }
         }
-        const existing = parsed[key];
+        const existing = parsed[key2];
         const list = Array.isArray(existing) ? existing.filter((v) => typeof v === "string") : [];
         if (list.includes(real)) {
           LOG2.debug("pre-launch-trust", `[${trust.settings_path}] ${real} already trusted \u2014 no change`);
           return null;
         }
         list.push(real);
-        parsed[key] = list;
+        parsed[key2] = list;
         fs14.mkdirSync(path222.dirname(settingsPath), { recursive: true });
         fs14.writeFileSync(settingsPath, `${JSON.stringify(parsed, null, 2)}
 `, "utf8");
-        LOG2.info("pre-launch-trust", `pre-trusted workspace in ${trust.settings_path} (key="${key}")`);
+        LOG2.info("pre-launch-trust", `pre-trusted workspace in ${trust.settings_path} (key="${key2}")`);
         return real;
       } catch (err) {
         LOG2.warn("pre-launch-trust", `failed to pre-trust workspace in ${trust.settings_path}: ${err.message}`);
@@ -68306,8 +68354,8 @@ ${body}
         }
         let end = i;
         while (end < expr.length && expr[end] !== "." && expr[end] !== "[") end += 1;
-        const key = expr.slice(i, end);
-        cur = cur[key];
+        const key2 = expr.slice(i, end);
+        cur = cur[key2];
         i = end;
       }
       return cur;
@@ -70268,8 +70316,8 @@ ${body}
       /** Drop user-input ack entries older than the dedup window so the map can't grow unbounded. */
       pruneRecentUserInputAcks(now) {
         if (this.recentUserInputAcks.size <= 1) return;
-        for (const [key, at] of this.recentUserInputAcks) {
-          if (now - at > USER_INPUT_ACK_DEDUP_WINDOW_MS) this.recentUserInputAcks.delete(key);
+        for (const [key2, at] of this.recentUserInputAcks) {
+          if (now - at > USER_INPUT_ACK_DEDUP_WINDOW_MS) this.recentUserInputAcks.delete(key2);
         }
       }
       dispose() {
@@ -71473,8 +71521,8 @@ ${effect.notification.body || ""}`.trim();
         };
         const isRuntimeOverlay = (entry) => {
           if (entry.source !== "runtime") return false;
-          const key = typeof entry.runtimeKey === "string" ? entry.runtimeKey.trim().toLowerCase() : "";
-          if (key.startsWith("auto_approval:")) return true;
+          const key2 = typeof entry.runtimeKey === "string" ? entry.runtimeKey.trim().toLowerCase() : "";
+          if (key2.startsWith("auto_approval:")) return true;
           return !isUserFacingChatMessage(entry.message);
         };
         const shouldKeepParsedBeforeUntimedRuntime = (message) => {
@@ -73071,16 +73119,16 @@ ${rawInput}` : rawInput;
     function hasCliArg(args, flag) {
       return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
     }
-    function hasConfigOverride(args, key) {
+    function hasConfigOverride(args, key2) {
       for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         const next = args[index + 1];
         if ((arg === "-c" || arg === "--config") && typeof next === "string") {
-          if (next === key || next.startsWith(`${key}=`) || next.startsWith(`${key}.`)) return true;
+          if (next === key2 || next.startsWith(`${key2}=`) || next.startsWith(`${key2}.`)) return true;
         }
         if (arg.startsWith("--config=")) {
           const value = arg.slice("--config=".length);
-          if (value === key || value.startsWith(`${key}=`) || value.startsWith(`${key}.`)) return true;
+          if (value === key2 || value.startsWith(`${key2}=`) || value.startsWith(`${key2}.`)) return true;
         }
       }
       return false;
@@ -73097,10 +73145,10 @@ ${rawInput}` : rawInput;
       const cliArgs = Array.isArray(input.cliArgs) ? [...input.cliArgs] : [];
       const env2 = { ...input.env || {} };
       const envUnsets = new Set(DEFAULT_COORDINATOR_DELEGATED_ENV_UNSETS);
-      for (const key of input.isolation?.env?.unset || []) {
-        if (typeof key === "string" && key.trim()) envUnsets.add(key.trim());
+      for (const key2 of input.isolation?.env?.unset || []) {
+        if (typeof key2 === "string" && key2.trim()) envUnsets.add(key2.trim());
       }
-      for (const key of envUnsets) env2[key] = "";
+      for (const key2 of envUnsets) env2[key2] = "";
       for (const rule of input.isolation?.args || []) {
         if (!rule || typeof rule !== "object") continue;
         if (rule.mode === "empty_mcp_config") {
@@ -73113,9 +73161,9 @@ ${rawInput}` : rawInput;
           continue;
         }
         if (rule.mode === "config_override") {
-          const key = String(rule.dedupeKey || rule.key || "").trim();
+          const key2 = String(rule.dedupeKey || rule.key || "").trim();
           const flag = String(rule.flag || "").trim();
-          if (!key || !flag || hasConfigOverride(cliArgs, key)) continue;
+          if (!key2 || !flag || hasConfigOverride(cliArgs, key2)) continue;
           cliArgs.unshift(flag, `${rule.key}=${rule.value}`);
         }
       }
@@ -73321,12 +73369,12 @@ ${rawInput}` : rawInput;
         }
         throw new Error(`No CLI provider found for '${cliType}'. Create a provider.js in providers/cli/${cliType}/`);
       }
-      startCliExitMonitor(key, cliType) {
+      startCliExitMonitor(key2, cliType) {
         const sessionRegistry = this.deps.getSessionRegistry?.() || null;
         const instanceManager = this.deps.getInstanceManager();
         const checkStopped = setInterval(() => {
           try {
-            const adapter = this.adapters.get(key);
+            const adapter = this.adapters.get(key2);
             if (!adapter) {
               clearInterval(checkStopped);
               return;
@@ -73335,12 +73383,12 @@ ${rawInput}` : rawInput;
             if (status?.status === "stopped" || status?.status === "error") {
               clearInterval(checkStopped);
               setTimeout(() => {
-                if (this.adapters.has(key)) {
-                  this.adapters.delete(key);
-                  this.deps.removeAgentTracking(key);
-                  sessionRegistry?.unregisterByInstanceKey(key);
-                  instanceManager?.removeInstance(key);
-                  unregisterMeshCoordinator(key);
+                if (this.adapters.has(key2)) {
+                  this.adapters.delete(key2);
+                  this.deps.removeAgentTracking(key2);
+                  sessionRegistry?.unregisterByInstanceKey(key2);
+                  instanceManager?.removeInstance(key2);
+                  unregisterMeshCoordinator(key2);
                   LOG2.info("CLI", `\u{1F9F9} Auto-cleaned ${status.status} CLI: ${cliType}`);
                   this.deps.onStatusChange();
                 }
@@ -73350,21 +73398,21 @@ ${rawInput}` : rawInput;
           }
         }, 3e3);
       }
-      async registerCliInstance(key, normalizedType, cliType, resolvedDir, cliArgs, provider, settings, attachExisting = false, options) {
+      async registerCliInstance(key2, normalizedType, cliType, resolvedDir, cliArgs, provider, settings, attachExisting = false, options) {
         const instanceManager = this.deps.getInstanceManager();
         const sessionRegistry = this.deps.getSessionRegistry?.() || null;
         if (!instanceManager) throw new Error("InstanceManager not available");
         const transportFactory = this.getTransportFactory(
-          key,
+          key2,
           normalizedType,
           resolvedDir,
           cliArgs,
           options?.providerSessionId,
           attachExisting
         );
-        const cliInstance = new CliProviderInstance(provider, resolvedDir, cliArgs, key, transportFactory, options);
+        const cliInstance = new CliProviderInstance(provider, resolvedDir, cliArgs, key2, transportFactory, options);
         try {
-          await instanceManager.addInstance(key, cliInstance, {
+          await instanceManager.addInstance(key2, cliInstance, {
             serverConn: this.deps.getServerConn(),
             settings,
             onPtyData: (data) => {
@@ -73376,8 +73424,8 @@ ${rawInput}` : rawInput;
             parentSessionId: null,
             providerType: normalizedType,
             transport: "pty",
-            adapterKey: key,
-            instanceKey: key,
+            adapterKey: key2,
+            instanceKey: key2,
             workspace: resolvedDir,
             // attachExisting === true means we're restoring an already-spawned
             // hosted runtime after a daemon restart, not starting a fresh PTY.
@@ -73393,10 +73441,10 @@ ${rawInput}` : rawInput;
           });
         } catch (spawnErr) {
           LOG2.error("CLI", `[${cliType}] Spawn failed: ${spawnErr?.message}`);
-          instanceManager.removeInstance(key);
+          instanceManager.removeInstance(key2);
           throw new Error(`Failed to start ${provider.displayName || provider.name || cliType}: ${spawnErr?.message}`);
         }
-        this.adapters.set(key, cliInstance.getAdapter());
+        this.adapters.set(key2, cliInstance.getAdapter());
         const launchMeshNodeId = typeof settings?.meshNodeId === "string" ? settings.meshNodeId.trim() : "";
         const launchMeshNodeFor = typeof settings?.meshNodeFor === "string" ? settings.meshNodeFor.trim() : "";
         if (launchMeshNodeId || launchMeshNodeFor) {
@@ -73409,7 +73457,7 @@ ${rawInput}` : rawInput;
           } catch {
           }
         }
-        this.startCliExitMonitor(key, cliType);
+        this.startCliExitMonitor(key2, cliType);
       }
       // ─── Session start/management ──────────────────────────────
       async startSession(cliType, workingDir, cliArgs, initialModel, options) {
@@ -73426,11 +73474,11 @@ ${rawInput}` : rawInput;
 Enable and detect this provider from the Machine Providers page before starting a runtime.`
           );
         }
-        const key = crypto5.randomUUID();
+        const key2 = crypto5.randomUUID();
         {
           const coordinatorMeshId = options?.settingsOverride?.meshCoordinatorFor;
           if (typeof coordinatorMeshId === "string" && coordinatorMeshId.trim()) {
-            options = { ...options, extraEnv: { ...options?.extraEnv || {}, ADHDEV_COORDINATOR_SESSION_ID: key } };
+            options = { ...options, extraEnv: { ...options?.extraEnv || {}, ADHDEV_COORDINATOR_SESSION_ID: key2 } };
           }
         }
         const sessionRegistry = this.deps.getSessionRegistry?.() || null;
@@ -73450,7 +73498,7 @@ ${installInfo}`
           }
           console.log(colorize("cyan", `  \u{1F50C} Starting ACP agent: ${provider.name} (${provider.type}) in ${resolvedDir}`));
           const acpInstance = new AcpProviderInstance(resolvedProvider, resolvedDir, cliArgs);
-          await instanceManager2.addInstance(key, acpInstance, {
+          await instanceManager2.addInstance(key2, acpInstance, {
             settings: this.providerLoader.getSettings(normalizedType)
           });
           const sessionId = acpInstance.getInstanceId();
@@ -73459,11 +73507,11 @@ ${installInfo}`
             parentSessionId: null,
             providerType: normalizedType,
             transport: "acp",
-            adapterKey: key,
-            instanceKey: key,
+            adapterKey: key2,
+            instanceKey: key2,
             workspace: resolvedDir
           });
-          this.adapters.set(key, {
+          this.adapters.set(key2, {
             cliType: normalizedType,
             cliName: provider.name,
             workingDir: resolvedDir,
@@ -73471,7 +73519,7 @@ ${installInfo}`
             spawn: async () => {
             },
             shutdown: () => {
-              instanceManager2.removeInstance(key);
+              instanceManager2.removeInstance(key2);
             },
             sendMessage: async (text) => {
               const input = normalizeInputEnvelope(text);
@@ -73487,7 +73535,7 @@ ${installInfo}`
             },
             getPartialResponse: () => "",
             cancel: () => {
-              instanceManager2.removeInstance(key);
+              instanceManager2.removeInstance(key2);
             },
             isProcessing: () => false,
             isReady: () => true,
@@ -73541,7 +73589,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         if (provider && instanceManager) {
           const resolvedProvider = this.providerLoader.resolve(cliType, { version: cliInfo.version }) || provider;
           await this.registerCliInstance(
-            key,
+            key2,
             normalizedType,
             cliType,
             resolvedDir,
@@ -73571,7 +73619,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
             cliType,
             resolvedDir,
             resolvedCliArgs,
-            key,
+            key2,
             sessionBinding.providerSessionId,
             false,
             options?.extraEnv
@@ -73591,9 +73639,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
             const status = adapter.getStatus?.();
             if (status?.status === "stopped" || status?.status === "error") {
               setTimeout(() => {
-                if (this.adapters.get(key) === adapter) {
-                  this.adapters.delete(key);
-                  this.deps.removeAgentTracking(key);
+                if (this.adapters.get(key2) === adapter) {
+                  this.adapters.delete(key2);
+                  this.deps.removeAgentTracking(key2);
                   LOG2.info("CLI", `\u{1F9F9} Auto-cleaned ${status.status} CLI: ${adapter.cliType}`);
                   this.deps.onStatusChange();
                 }
@@ -73602,10 +73650,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
           });
           if (typeof adapter.setOnPtyData === "function") {
             adapter.setOnPtyData((data) => {
-              this.deps.getP2p()?.broadcastSessionOutput(key, data);
+              this.deps.getP2p()?.broadcastSessionOutput(key2, data);
             });
           }
-          this.adapters.set(key, adapter);
+          this.adapters.set(key2, adapter);
           console.log(colorize("green", `  \u2713 CLI started: ${cliInfo.displayName} v${cliInfo.version || "unknown"} in ${resolvedDir}`));
         }
         this.persistRecentActivity({
@@ -73615,20 +73663,20 @@ Run 'adhdev doctor' for detailed diagnostics.`
           providerSessionId: sessionBinding.providerSessionId,
           workspace: resolvedDir,
           summaryMetadata: buildLegacyModelModeSummaryMetadata({ model: initialModel }),
-          sessionId: key,
+          sessionId: key2,
           title: provider?.displayName || provider?.name || normalizedType
         });
         this.deps.onStatusChange();
         return {
-          runtimeSessionId: key,
+          runtimeSessionId: key2,
           providerSessionId: sessionBinding.providerSessionId
         };
       }
-      async stopSession(key) {
-        return this.stopSessionWithMode(key, "hard");
+      async stopSession(key2) {
+        return this.stopSessionWithMode(key2, "hard");
       }
-      async stopSessionWithMode(key, mode) {
-        const adapter = this.adapters.get(key);
+      async stopSessionWithMode(key2, mode) {
+        const adapter = this.adapters.get(key2);
         if (adapter) {
           try {
             if (mode === "save" && typeof adapter.saveAndStop === "function") {
@@ -73639,21 +73687,21 @@ Run 'adhdev doctor' for detailed diagnostics.`
           } catch (e) {
             LOG2.warn("CLI", `Shutdown error for ${adapter.cliType}: ${e?.message} (force-cleaning)`);
           }
-          this.adapters.delete(key);
-          this.deps.removeAgentTracking(key);
-          this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
-          this.deps.getInstanceManager()?.removeInstance(key);
-          unregisterMeshCoordinator(key);
+          this.adapters.delete(key2);
+          this.deps.removeAgentTracking(key2);
+          this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key2);
+          this.deps.getInstanceManager()?.removeInstance(key2);
+          unregisterMeshCoordinator(key2);
           LOG2.info("CLI", `\u{1F6D1} Agent stopped: ${adapter.cliType} in ${adapter.workingDir}`);
           this.deps.onStatusChange();
         } else {
           const im = this.deps.getInstanceManager();
           if (im) {
-            this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
-            im.removeInstance(key);
-            this.deps.removeAgentTracking(key);
-            unregisterMeshCoordinator(key);
-            LOG2.warn("CLI", `\u{1F9F9} Force-removed orphan entry: ${key}`);
+            this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key2);
+            im.removeInstance(key2);
+            this.deps.removeAgentTracking(key2);
+            unregisterMeshCoordinator(key2);
+            LOG2.warn("CLI", `\u{1F9F9} Force-removed orphan entry: ${key2}`);
             this.deps.onStatusChange();
           }
         }
@@ -73681,8 +73729,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
         for (const r of sessions) {
           if (!r?.runtimeId || !r?.cliType || !r?.workspace) continue;
           restoredRuntimeIds.add(r.runtimeId);
-          const key = `${r.workspace}::${r.cliType}`;
-          workspaceTypeCounts.set(key, (workspaceTypeCounts.get(key) || 0) + 1);
+          const key2 = `${r.workspace}::${r.cliType}`;
+          workspaceTypeCounts.set(key2, (workspaceTypeCounts.get(key2) || 0) + 1);
         }
         for (const record2 of sessions) {
           if (!record2?.runtimeId || !record2?.cliType || !record2?.workspace) continue;
@@ -74036,7 +74084,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               });
             }
             if (!found) throw new Error(`CLI agent not running: ${agentType}`);
-            const { adapter, key } = found;
+            const { adapter, key: key2 } = found;
             if (action === "send_chat") {
               let currentStatus = getEffectiveAgentSendStatus(adapter);
               if (currentStatus === "starting" && await waitForZeroMessageStartingLaunch(adapter)) {
@@ -74046,7 +74094,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               }
               const meshContext = args?.meshContext;
               if (meshContext && typeof meshContext === "object" && typeof meshContext.meshId === "string" && meshContext.meshId) {
-                const targetInstanceId = key;
+                const targetInstanceId = key2;
                 try {
                   this.deps.getInstanceManager()?.attachMeshAssignmentToInstance(targetInstanceId, {
                     meshId: meshContext.meshId,
@@ -74078,7 +74126,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               } else {
                 await adapter.sendMessage(message);
               }
-              const targetInstance = this.deps.getInstanceManager()?.getInstance(key);
+              const targetInstance = this.deps.getInstanceManager()?.getInstance(key2);
               targetInstance?.recordAcknowledgedUserInput?.(input);
               return {
                 success: true,
@@ -74090,7 +74138,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               if (typeof adapter.clearHistory === "function") adapter.clearHistory();
               return { success: true, cleared: true };
             } else if (action === "stop") {
-              await this.stopSession(key);
+              await this.stopSession(key2);
               return { success: true, stopped: true };
             }
             throw new Error(`Unknown action: ${action}`);
@@ -74354,9 +74402,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
       } else if (!["ide", "extension", "cli", "acp"].includes(String(provider.category))) {
         errors.push(`Invalid category: ${String(provider.category)}`);
       }
-      for (const key of Object.keys(provider)) {
-        if (!KNOWN_PROVIDER_FIELDS.has(key)) {
-          warnings.push(`Unknown provider field: ${key}`);
+      for (const key2 of Object.keys(provider)) {
+        if (!KNOWN_PROVIDER_FIELDS.has(key2)) {
+          warnings.push(`Unknown provider field: ${key2}`);
         }
       }
       if (provider.disableUpstream !== void 0) {
@@ -74501,10 +74549,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
         return;
       }
       const scriptConfig = scripts;
-      for (const key of ["readSession", "listSessions"]) {
-        const value = scriptConfig[key];
+      for (const key2 of ["readSession", "listSessions"]) {
+        const value = scriptConfig[key2];
         if (typeof value !== "string" || !value.trim()) {
-          errors.push(`nativeHistory.scripts.${key} must be a non-empty string`);
+          errors.push(`nativeHistory.scripts.${key2} must be a non-empty string`);
         }
       }
     }
@@ -74539,10 +74587,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
       if (format !== void 0 && !["claude_mcp_json", "hermes_config_yaml"].includes(String(format))) {
         errors.push("meshCoordinator.mcpConfig.format must be one of: claude_mcp_json, hermes_config_yaml");
       }
-      for (const key of ["path", "serverName", "configPathCommand", "instructions", "template"]) {
-        const value = config2[key];
+      for (const key2 of ["path", "serverName", "configPathCommand", "instructions", "template"]) {
+        const value = config2[key2];
         if (value !== void 0 && (typeof value !== "string" || !value.trim())) {
-          errors.push(`meshCoordinator.mcpConfig.${key} must be a non-empty string when provided`);
+          errors.push(`meshCoordinator.mcpConfig.${key2} must be a non-empty string when provided`);
         }
       }
       if (config2.requiresRestart !== void 0 && typeof config2.requiresRestart !== "boolean") {
@@ -74578,7 +74626,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           errors.push("meshCoordinator.delegatedWorkerIsolation.env must be an object");
         } else {
           const unset = env2.unset;
-          if (unset !== void 0 && (!Array.isArray(unset) || unset.some((key) => typeof key !== "string" || !key.trim()))) {
+          if (unset !== void 0 && (!Array.isArray(unset) || unset.some((key2) => typeof key2 !== "string" || !key2.trim()))) {
             errors.push("meshCoordinator.delegatedWorkerIsolation.env.unset must be an array of non-empty strings");
           }
         }
@@ -74601,16 +74649,16 @@ Run 'adhdev doctor' for detailed diagnostics.`
           errors.push(`${prefix}.mode must be one of: empty_mcp_config, config_override`);
           continue;
         }
-        for (const key of mode === "empty_mcp_config" ? ["flag"] : ["flag", "key", "value"]) {
-          const value = item[key];
+        for (const key2 of mode === "empty_mcp_config" ? ["flag"] : ["flag", "key", "value"]) {
+          const value = item[key2];
           if (typeof value !== "string" || !value.trim()) {
-            errors.push(`${prefix}.${key} must be a non-empty string`);
+            errors.push(`${prefix}.${key2} must be a non-empty string`);
           }
         }
-        for (const key of ["strictFlag", "dedupeKey"]) {
-          const value = item[key];
+        for (const key2 of ["strictFlag", "dedupeKey"]) {
+          const value = item[key2];
           if (value !== void 0 && (typeof value !== "string" || !value.trim())) {
-            errors.push(`${prefix}.${key} must be a non-empty string when provided`);
+            errors.push(`${prefix}.${key2} must be a non-empty string when provided`);
           }
         }
       }
@@ -76817,9 +76865,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
       reload() {
         this.log("Reloading all providers...");
         this.scriptsCache.clear();
-        for (const key of Object.keys(require.cache)) {
-          if (key.includes("providers") && (key.endsWith(".js") || key.endsWith(".json"))) {
-            delete require.cache[key];
+        for (const key2 of Object.keys(require.cache)) {
+          if (key2.includes("providers") && (key2.endsWith(".js") || key2.endsWith(".json"))) {
+            delete require.cache[key2];
           }
         }
         this.loadAll();
@@ -77127,7 +77175,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       */
       getPublicSettings(type) {
         const settings = this.getSettingsSchema(type);
-        return Object.entries(settings).filter(([, def]) => def.public === true).map(([key, def]) => ({ key, ...def }));
+        return Object.entries(settings).filter(([, def]) => def.public === true).map(([key2, def]) => ({ key: key2, ...def }));
       }
       /**
       * Get public settings schema for all providers
@@ -77143,23 +77191,23 @@ Run 'adhdev doctor' for detailed diagnostics.`
       /**
       * Resolved setting value for a provider (default + user override)
       */
-      getSettingValue(type, key) {
+      getSettingValue(type, key2) {
         const providerType = this.resolveAlias(type);
         const machineConfig = this.getMachineProviderConfig(providerType);
-        if (key === "enabled") {
+        if (key2 === "enabled") {
           return machineConfig.enabled === true;
         }
-        if (key === "executablePath") {
+        if (key2 === "executablePath") {
           return machineConfig.executable || "";
         }
-        if (key === "executableArgs") {
+        if (key2 === "executableArgs") {
           const args = machineConfig.args;
           return args ? args.map((arg) => /\s/.test(arg) ? JSON.stringify(arg) : arg).join(" ") : "";
         }
-        const schemaDef = this.getSettingsSchema(providerType)[key];
+        const schemaDef = this.getSettingsSchema(providerType)[key2];
         const defaultVal = schemaDef ? schemaDef.default : void 0;
         const config2 = this.readConfig();
-        const userVal = config2?.providerSettings?.[providerType]?.[key];
+        const userVal = config2?.providerSettings?.[providerType]?.[key2];
         return userVal !== void 0 ? userVal : defaultVal;
       }
       /**
@@ -77169,17 +77217,17 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const providerType = this.resolveAlias(type);
         const settings = this.getSettingsSchema(providerType);
         const result = {};
-        for (const [key] of Object.entries(settings)) {
-          result[key] = this.getSettingValue(providerType, key);
+        for (const [key2] of Object.entries(settings)) {
+          result[key2] = this.getSettingValue(providerType, key2);
         }
         return result;
       }
       /**
       * Save provider setting value (writes to config.json)
       */
-      setSetting(type, key, value) {
+      setSetting(type, key2, value) {
         const providerType = this.resolveAlias(type);
-        const schemaDef = this.getSettingsSchema(providerType)[key];
+        const schemaDef = this.getSettingsSchema(providerType)[key2];
         if (!schemaDef) return false;
         if (!schemaDef.public) return false;
         if (schemaDef.type === "boolean" && typeof value !== "boolean") return false;
@@ -77190,13 +77238,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
           if (schemaDef.max !== void 0 && value > schemaDef.max) return false;
         }
         if (schemaDef.type === "select" && schemaDef.options && !schemaDef.options.includes(value)) return false;
-        if (key === "enabled") {
+        if (key2 === "enabled") {
           return this.setMachineProviderEnabled(providerType, value);
         }
-        if (key === "executablePath") {
+        if (key2 === "executablePath") {
           return this.setMachineProviderConfig(providerType, { executable: value });
         }
-        if (key === "executableArgs") {
+        if (key2 === "executableArgs") {
           return this.setMachineProviderConfig(providerType, {
             args: value.trim() ? this.parseArgsSetting(value) : void 0
           });
@@ -77206,17 +77254,17 @@ Run 'adhdev doctor' for detailed diagnostics.`
         try {
           if (!config2.providerSettings) config2.providerSettings = {};
           if (!config2.providerSettings[providerType]) config2.providerSettings[providerType] = {};
-          config2.providerSettings[providerType][key] = value;
+          config2.providerSettings[providerType][key2] = value;
           this.writeConfig(config2);
-          this.log(`Setting updated: ${providerType}.${key} = ${JSON.stringify(value)}`);
+          this.log(`Setting updated: ${providerType}.${key2} = ${JSON.stringify(value)}`);
           return true;
         } catch (e) {
           this.log(`Failed to save setting: ${e.message}`);
           return false;
         }
       }
-      getOptionalStringSetting(type, key) {
-        const value = this.getSettingValue(type, key);
+      getOptionalStringSetting(type, key2) {
+        const value = this.getSettingValue(type, key2);
         if (typeof value !== "string") return null;
         const trimmed = value.trim();
         return trimmed ? trimmed : null;
@@ -77396,7 +77444,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               try {
                 let content = fs25.readFileSync(filePath, "utf-8");
                 if (args[0] && typeof args[0] === "object") {
-                  for (const [key, val] of Object.entries(args[0])) {
+                  for (const [key2, val] of Object.entries(args[0])) {
                     let v = val;
                     if (typeof v === "string") {
                       if (!v.startsWith('"') && !v.startsWith("'") && !v.startsWith("`")) {
@@ -77405,7 +77453,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                     } else {
                       v = JSON.stringify(v);
                     }
-                    const re = new RegExp(`\\$\\{\\s*${key}\\s*\\}`, "g");
+                    const re = new RegExp(`\\$\\{\\s*${key2}\\s*\\}`, "g");
                     content = content.replace(re, String(v));
                   }
                 } else if (typeof args[0] === "string") {
@@ -79145,9 +79193,20 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             targetNodeId: typeof args?.targetNodeId === "string" ? args.targetNodeId.trim() : void 0,
             targetSessionId: typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : void 0,
             clearTargetNode: args?.clearTargetNode === true,
-            clearTargetSession: args?.clearTargetSession !== false
+            clearTargetSession: args?.clearTargetSession !== false,
+            // CANON-IDENTITY: an in-flight (actively-generating) task is refused by
+            // default to avoid a duplicate second dispatch; an explicit operator
+            // force overrides that guard (and the retry cap).
+            force: args?.force === true
           });
           if (!task) return { success: false, error: `Queue task '${taskId}' not found` };
+          if (task.status === "assigned" && args?.force !== true) {
+            return {
+              success: false,
+              error: `Task '${taskId}' is actively dispatched/generating; requeue refused to avoid a duplicate second dispatch. Pass force:true to override, or cancel and re-enqueue.`,
+              task
+            };
+          }
           return { success: true, task };
         } catch (e) {
           return { success: false, error: e.message };
@@ -80652,15 +80711,15 @@ ${ptyResult.output.slice(-2e3)}`);
     function maskArgs(args) {
       if (!args || typeof args !== "object") return void 0;
       const masked = {};
-      for (const [key, value] of Object.entries(args)) {
-        if (SENSITIVE_KEYS.has(key)) {
-          masked[key] = typeof value === "string" ? `[${value.length} chars]` : "[masked]";
-        } else if (key.startsWith("_")) {
-          masked[key] = value;
+      for (const [key2, value] of Object.entries(args)) {
+        if (SENSITIVE_KEYS.has(key2)) {
+          masked[key2] = typeof value === "string" ? `[${value.length} chars]` : "[masked]";
+        } else if (key2.startsWith("_")) {
+          masked[key2] = value;
         } else if (typeof value === "object" && value !== null) {
-          masked[key] = Array.isArray(value) ? `[Array(${value.length})]` : `[Object]`;
+          masked[key2] = Array.isArray(value) ? `[Array(${value.length})]` : `[Object]`;
         } else {
-          masked[key] = value;
+          masked[key2] = value;
         }
       }
       return masked;
@@ -81749,23 +81808,23 @@ ${ptyResult.output.slice(-2e3)}`);
        * neither gate is satisfied.
        */
       async probe(daemonId, workspace, probe) {
-        const key = this.key(daemonId, workspace);
-        const cached3 = this.recent.get(key);
+        const key2 = this.key(daemonId, workspace);
+        const cached3 = this.recent.get(key2);
         if (cached3 && this.now() - cached3.at < this.reuseMs) {
           return cached3.value;
         }
-        const existing = this.inflight.get(key);
+        const existing = this.inflight.get(key2);
         if (existing) return existing;
         const pending = (async () => {
           const result = await probe();
-          if (result) this.recent.set(key, { at: this.now(), value: result });
+          if (result) this.recent.set(key2, { at: this.now(), value: result });
           return result;
         })();
-        this.inflight.set(key, pending);
+        this.inflight.set(key2, pending);
         try {
           return await pending;
         } finally {
-          if (this.inflight.get(key) === pending) this.inflight.delete(key);
+          if (this.inflight.get(key2) === pending) this.inflight.delete(key2);
         }
       }
     };
@@ -84457,8 +84516,8 @@ ${mergeTreeErr?.stderr || ""}`;
               if (source !== "refine_mesh_node_async_job") continue;
               const jobId = e.payload?.refineJob?.jobId;
               if (!jobId || terminal.has(`${e.nodeId}:${jobId}`)) continue;
-              const key = this.buildRefineJobKey(meshId, e.nodeId);
-              if (this.runningRefineJobs.has(key)) continue;
+              const key2 = this.buildRefineJobKey(meshId, e.nodeId);
+              if (this.runningRefineJobs.has(key2)) continue;
               const coordinatorDaemonId = e.payload?.refineJob?.targetCoordinatorDaemonId;
               LOG2.info("Mesh", `[Refinery] Auto-resuming interrupted refine job for node ${e.nodeId} (jobId=${jobId})`);
               void this.startMeshRefineJob(meshId, e.nodeId, {
@@ -85541,7 +85600,7 @@ ${hintLines.join("\n")}` : "",
         }
       }
       async finishMeshRefineBatchJob(handle, orderedNodes, ordering, args) {
-        const key = this.buildRefineBatchJobKey(handle.meshId);
+        const key2 = this.buildRefineBatchJobKey(handle.meshId);
         let result;
         try {
           result = await this.runMeshRefineBatchConvergence(handle.meshId, orderedNodes, ordering, args);
@@ -85573,8 +85632,8 @@ ${hintLines.join("\n")}` : "",
           coordinatorDaemonId: handle.targetCoordinatorDaemonId
         });
         const terminal = { ...terminalHandle, result: normalizedResult };
-        this.terminalRefineBatchJobs.set(key, terminal);
-        this.runningRefineBatchJobs.delete(key);
+        this.terminalRefineBatchJobs.set(key2, terminal);
+        this.runningRefineBatchJobs.delete(key2);
         this.invalidateAggregateMeshStatus(handle.meshId);
         await this.appendRefineBatchJobLedger(isTerminalSuccess ? "task_completed" : "task_failed", terminalHandle, normalizedResult);
         this.queueRefineBatchJobEvent(isTerminalSuccess ? "refine:completed" : "refine:failed", terminalHandle, normalizedResult);
@@ -85598,8 +85657,8 @@ ${hintLines.join("\n")}` : "",
         if (nodeIds.length === 0) {
           return { ...planRecord, success: true, batch: true, dryRun: false, async: false };
         }
-        const key = this.buildRefineBatchJobKey(meshId);
-        const running = this.runningRefineBatchJobs.get(key);
+        const key2 = this.buildRefineBatchJobKey(meshId);
+        const running = this.runningRefineBatchJobs.get(key2);
         if (running) return { ...running, duplicate: true };
         const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
         const mesh = meshRecord?.mesh;
@@ -85614,7 +85673,7 @@ ${hintLines.join("\n")}` : "",
         };
         const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : this.deps.statusInstanceId || void 0;
         const handle = this.buildRefineBatchJobHandle({ meshId, nodeIds, order, coordinatorDaemonId });
-        this.runningRefineBatchJobs.set(key, handle);
+        this.runningRefineBatchJobs.set(key2, handle);
         await this.appendRefineBatchJobLedger("task_dispatched", handle);
         this.queueRefineBatchJobEvent("refine:accepted", handle);
         setImmediate(() => {
@@ -85629,7 +85688,7 @@ ${hintLines.join("\n")}` : "",
         };
       }
       async finishMeshRefineJob(handle, args) {
-        const key = this.buildRefineJobKey(handle.meshId, handle.targetNodeId);
+        const key2 = this.buildRefineJobKey(handle.meshId, handle.targetNodeId);
         let result;
         try {
           result = await this.executeMeshRefineNodeSynchronously(handle.meshId, handle.targetNodeId, args);
@@ -85697,17 +85756,17 @@ ${hintLines.join("\n")}` : "",
           coordinatorDaemonId: handle.targetCoordinatorDaemonId
         });
         const terminal = { ...terminalHandle, result: normalizedResult };
-        this.terminalRefineJobs.set(key, terminal);
-        this.runningRefineJobs.delete(key);
+        this.terminalRefineJobs.set(key2, terminal);
+        this.runningRefineJobs.delete(key2);
         this.invalidateAggregateMeshStatus(handle.meshId);
         await this.appendRefineJobLedger(isTerminalSuccess ? "task_completed" : "task_failed", terminalHandle, normalizedResult);
         this.queueRefineJobEvent(isTerminalSuccess ? "refine:completed" : "refine:failed", terminalHandle, normalizedResult);
       }
       async startMeshRefineJob(meshId, nodeId, args) {
-        const key = this.buildRefineJobKey(meshId, nodeId);
-        const running = this.runningRefineJobs.get(key);
+        const key2 = this.buildRefineJobKey(meshId, nodeId);
+        const running = this.runningRefineJobs.get(key2);
         if (running) return { ...running, duplicate: true };
-        const terminal = this.terminalRefineJobs.get(key);
+        const terminal = this.terminalRefineJobs.get(key2);
         const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
         const mesh = meshRecord?.mesh;
         const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
@@ -85715,7 +85774,7 @@ ${hintLines.join("\n")}` : "",
         if (!node.isLocalWorktree || !node.workspace) return { success: false, error: `Refinery requires a local worktree node` };
         const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : this.deps.statusInstanceId || void 0;
         const handle = this.buildRefineJobHandle({ meshId, nodeId, node, retryOfJobId: terminal?.jobId, coordinatorDaemonId });
-        this.runningRefineJobs.set(key, handle);
+        this.runningRefineJobs.set(key2, handle);
         await this.appendRefineJobLedger("task_dispatched", handle);
         this.queueRefineJobEvent("refine:accepted", handle);
         setImmediate(() => {
@@ -85771,27 +85830,27 @@ ${hintLines.join("\n")}` : "",
        */
       async stopIde(ideType, killProcess = false) {
         const cdpKeysToRemove = [];
-        for (const key of this.deps.cdpManagers.keys()) {
-          if (key === ideType || key.startsWith(`${ideType}_`)) {
-            cdpKeysToRemove.push(key);
+        for (const key2 of this.deps.cdpManagers.keys()) {
+          if (key2 === ideType || key2.startsWith(`${ideType}_`)) {
+            cdpKeysToRemove.push(key2);
           }
         }
-        for (const key of cdpKeysToRemove) {
-          const cdp = this.deps.cdpManagers.get(key);
+        for (const key2 of cdpKeysToRemove) {
+          const cdp = this.deps.cdpManagers.get(key2);
           if (cdp) {
             try {
               cdp.disconnect();
             } catch {
             }
-            this.deps.cdpManagers.delete(key);
-            this.deps.sessionRegistry.unregisterByManagerKey(key);
-            LOG2.info("StopIDE", `CDP disconnected: ${key}`);
+            this.deps.cdpManagers.delete(key2);
+            this.deps.sessionRegistry.unregisterByManagerKey(key2);
+            LOG2.info("StopIDE", `CDP disconnected: ${key2}`);
           }
         }
         const keysToRemove = [];
-        for (const key of this.deps.instanceManager.listInstanceIds()) {
-          if (key === `ide:${ideType}` || typeof key === "string" && key.startsWith(`ide:${ideType}_`)) {
-            keysToRemove.push(key);
+        for (const key2 of this.deps.instanceManager.listInstanceIds()) {
+          if (key2 === `ide:${ideType}` || typeof key2 === "string" && key2.startsWith(`ide:${ideType}_`)) {
+            keysToRemove.push(key2);
           }
         }
         for (const instanceKey of keysToRemove) {
@@ -90446,9 +90505,9 @@ async (params) => {
           }
           if (Date.now() - lastApprovalTime < 2e3) return;
           if (approvalPatterns.some((p) => p.test(approvalBuffer))) {
-            const key = approvalKeys[1] || approvalKeys[0] || "a\r";
-            writeFn(key);
-            ctx.log(`Auto-Implement auto-approved prompt! Sending: ${JSON.stringify(key)}`);
+            const key2 = approvalKeys[1] || approvalKeys[0] || "a\r";
+            writeFn(key2);
+            ctx.log(`Auto-Implement auto-approved prompt! Sending: ${JSON.stringify(key2)}`);
             sendAutoImplSSE(ctx, { event: "output", data: { chunk: `
 [\u{1F916} ADHDev Auto-Approve] CLI Action Approved
 `, stream: "stdout" } });
@@ -91698,8 +91757,8 @@ data: ${JSON.stringify(msg.data)}
           category: p.category
         }));
         const cdpStatus = {};
-        for (const [key, cdp] of this.cdpManagers.entries()) {
-          cdpStatus[key] = { connected: cdp.isConnected };
+        for (const [key2, cdp] of this.cdpManagers.entries()) {
+          cdpStatus[key2] = { connected: cdp.isConnected };
         }
         this.json(res, 200, {
           devMode: true,
@@ -92019,16 +92078,16 @@ data: ${JSON.stringify(msg.data)}
           errors.push(...validation.errors);
           warnings.push(...validation.warnings);
           if (config2.settings) {
-            for (const [key, val] of Object.entries(config2.settings)) {
+            for (const [key2, val] of Object.entries(config2.settings)) {
               const s2 = val;
-              if (!s2.type) errors.push(`settings.${key}: missing type`);
+              if (!s2.type) errors.push(`settings.${key2}: missing type`);
               else if (!["boolean", "number", "string", "select"].includes(s2.type))
-                errors.push(`settings.${key}: invalid type '${s2.type}'`);
-              if (s2.default === void 0) warnings.push(`settings.${key}: no default value`);
+                errors.push(`settings.${key2}: invalid type '${s2.type}'`);
+              if (s2.default === void 0) warnings.push(`settings.${key2}: no default value`);
               if (s2.type === "number" && s2.min !== void 0 && s2.max !== void 0 && s2.min > s2.max)
-                errors.push(`settings.${key}: min (${s2.min}) > max (${s2.max})`);
+                errors.push(`settings.${key2}: min (${s2.min}) > max (${s2.max})`);
               if (s2.type === "select" && (!s2.options || !Array.isArray(s2.options) || s2.options.length === 0))
-                errors.push(`settings.${key}: select type requires options[]`);
+                errors.push(`settings.${key2}: select type requires options[]`);
             }
           }
           if (config2.cdpPorts && Array.isArray(config2.cdpPorts)) {
@@ -92806,21 +92865,21 @@ data: ${JSON.stringify(msg.data)}
     function encodeControlLetter(letter) {
       return String.fromCharCode(letter.charCodeAt(0) - 96);
     }
-    function encodeShiftedKey(key) {
-      if (isLowercaseLetter(key)) return key.toUpperCase();
-      if (key.startsWith("ctrl+") && isLowercaseLetter(key.slice(5))) {
-        return encodeControlLetter(key.slice(5));
+    function encodeShiftedKey(key2) {
+      if (isLowercaseLetter(key2)) return key2.toUpperCase();
+      if (key2.startsWith("ctrl+") && isLowercaseLetter(key2.slice(5))) {
+        return encodeControlLetter(key2.slice(5));
       }
-      if (key.startsWith("alt+") && isLowercaseLetter(key.slice(4))) {
-        return `\x1B${key.slice(4).toUpperCase()}`;
+      if (key2.startsWith("alt+") && isLowercaseLetter(key2.slice(4))) {
+        return `\x1B${key2.slice(4).toUpperCase()}`;
       }
-      if (key === "tab") return "\x1B[Z";
-      if (key in SHIFTED_CSI_KEYS) return SHIFTED_CSI_KEYS[key];
-      if (key in BASE_KEY_SEQUENCES) return BASE_KEY_SEQUENCES[key];
-      throw new Error(`Unsupported named key: shift+${key}`);
+      if (key2 === "tab") return "\x1B[Z";
+      if (key2 in SHIFTED_CSI_KEYS) return SHIFTED_CSI_KEYS[key2];
+      if (key2 in BASE_KEY_SEQUENCES) return BASE_KEY_SEQUENCES[key2];
+      throw new Error(`Unsupported named key: shift+${key2}`);
     }
-    function namedKeyToAnsi(key) {
-      const normalized = String(key || "").trim().toLowerCase();
+    function namedKeyToAnsi(key2) {
+      const normalized = String(key2 || "").trim().toLowerCase();
       if (normalized in BASE_KEY_SEQUENCES) return BASE_KEY_SEQUENCES[normalized];
       if (normalized.startsWith("ctrl+") && isLowercaseLetter(normalized.slice(5))) {
         return encodeControlLetter(normalized.slice(5));
@@ -92829,7 +92888,7 @@ data: ${JSON.stringify(msg.data)}
         return `\x1B${normalized.slice(4)}`;
       }
       if (normalized.startsWith("shift+")) return encodeShiftedKey(normalized.slice(6));
-      throw new Error(`Unsupported named key: ${key}`);
+      throw new Error(`Unsupported named key: ${key2}`);
     }
     function namedKeysToAnsi(keys) {
       if (!Array.isArray(keys)) throw new Error("keys must be an array");
@@ -93295,19 +93354,19 @@ data: ${JSON.stringify(msg.data)}
         if (!ids) return [];
         return [...ids].map((id) => this.bySessionId.get(id)).filter(Boolean);
       }
-      addIndex(index, key, sessionId) {
-        let set2 = index.get(key);
+      addIndex(index, key2, sessionId) {
+        let set2 = index.get(key2);
         if (!set2) {
           set2 = /* @__PURE__ */ new Set();
-          index.set(key, set2);
+          index.set(key2, set2);
         }
         set2.add(sessionId);
       }
-      removeIndex(index, key, sessionId) {
-        const set2 = index.get(key);
+      removeIndex(index, key2, sessionId) {
+        const set2 = index.get(key2);
         if (!set2) return;
         set2.delete(sessionId);
-        if (set2.size === 0) index.delete(key);
+        if (set2.size === 0) index.delete(key2);
       }
     };
     init_logger();