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

@adhdev/daemon-core 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 (12) hide show

package/dist/index.d.ts +1 -1
package/dist/index.js +449 -387
package/dist/index.js.map +1 -1
package/dist/index.mjs +448 -387
package/dist/index.mjs.map +1 -1
package/dist/mesh/mesh-task-inflight.d.ts +46 -0
package/package.json +2 -2
package/src/commands/med-family/mesh-queue.ts +14 -0
package/src/index.ts +1 -1
package/src/mesh/mesh-queue-assignment.ts +54 -10
package/src/mesh/mesh-task-inflight.ts +70 -0
package/src/mesh/mesh-work-queue.ts +25 -0

package/dist/index.js CHANGED Viewed

@@ -14,9 +14,9 @@ var __export = (target, all) => {
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
   }
   return to;
 };
@@ -389,10 +389,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "f8bbe838081c3b3e14df690b3ed24568979f635e" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "f8bbe838" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = 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:03.423Z" : 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 version = 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:50:52.585Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -410,18 +410,18 @@ function isRecord(value) {
 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 };
 }
@@ -448,20 +448,20 @@ function validateChangeImpactConfig(raw, source = "inline") {
       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) config.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 ? config : void 0 };
@@ -793,12 +793,12 @@ function resolveChangeImpactConfigForRepo(repoRoot, options) {
     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" };
@@ -2359,9 +2359,9 @@ function dismissSessionNotification(state, sessionId, notificationId, providerSe
   ].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,
@@ -2378,9 +2378,9 @@ function markSessionNotificationUnread(state, sessionId, notificationId, provide
   ].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,
@@ -2444,11 +2444,11 @@ function markSessionSeen(state, sessionId, seenAt = Date.now(), completionMarker
   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,
@@ -3153,6 +3153,12 @@ function machineCoreFromDaemonId(id) {
   }
   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);
@@ -3314,8 +3320,8 @@ function expandPromptPlaceholders(template, ctx) {
     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) {
@@ -4718,6 +4724,33 @@ var init_mesh_delivery_policy = __esm({
   }
 });
+// src/mesh/mesh-task-inflight.ts
+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 = __esm({
+  "src/mesh/mesh-task-inflight.ts"() {
+    "use strict";
+    inFlight = /* @__PURE__ */ new Set();
+  }
+});
 // src/mesh/mesh-work-queue.ts
 var mesh_work_queue_exports = {};
 __export(mesh_work_queue_exports, {
@@ -4984,14 +5017,14 @@ function firstProviderPriority(policy) {
   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) {
@@ -5210,6 +5243,7 @@ function updateTaskStatus(meshId, taskId, status, opts) {
     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;
   });
@@ -5234,6 +5268,7 @@ function cancelTask(meshId, taskId, opts) {
     entry.cancelledAt = now;
     if (opts?.reason) entry.cancelReason = opts.reason;
     MeshRuntimeStore.getInstance().updateQueueEntry(entry);
+    endTaskDispatchInFlight(meshId, taskId);
     propagateDependencyFailure(meshId, taskId);
     return entry;
   });
@@ -5243,6 +5278,11 @@ function requeueTask(meshId, taskId, opts) {
   return withQueueLock(meshId, () => {
     const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
     if (!entry) return null;
+    if (!opts?.force && isTaskDispatchInFlight(meshId, taskId)) {
+      LOG.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) {
@@ -5287,6 +5327,7 @@ function reclaimStrandedAssignedTask(meshId, taskId, opts) {
     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`;
@@ -5330,6 +5371,7 @@ function updateSessionTaskStatus(meshId, sessionId, status, opts) {
     }
     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;
   });
@@ -5444,6 +5486,7 @@ var init_mesh_work_queue = __esm({
     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"];
@@ -7509,7 +7552,7 @@ function resolveNodeEvidence(nodeId, ledgerEntries) {
           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) } : {},
@@ -7774,7 +7817,7 @@ function resolveMeshCoordinatorSetup(options) {
   };
 }
 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(
@@ -7783,9 +7826,9 @@ function replaceLegacyCliCommandMcpArgs(command, args) {
   );
 }
 function resolveHermesCoordinatorHome(meshId, workspace) {
-  const key = `${meshId || "mesh"}
+  const key2 = `${meshId || "mesh"}
 ${(0, import_node_path.resolve)(workspace || os4.tmpdir())}`;
-  const hash = shortHash(key);
+  const hash = shortHash(key2);
   return (0, import_node_path.join)(os4.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
 }
 function resolveMcpConfigPath(configPath, workspace) {
@@ -8256,9 +8299,9 @@ function suggestMeshRefineConfig(mesh, workspace) {
   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 {
@@ -11752,6 +11795,9 @@ var init_mesh_warmup_deadline = __esm({
 });
 // src/mesh/mesh-queue-assignment.ts
+function localCoordinatorDaemonId() {
+  return canonicalDaemonId(readNonEmptyString2(loadConfig().machineId));
+}
 function __resetIdleAutoFastForwardForTests() {
   idleAutoFastForwardLastAttempt.clear();
 }
@@ -11837,6 +11883,7 @@ function deliverTaskToSession(dispatchThunk, ctx, warmup) {
     if (timer) clearTimeout(timer);
     LOG.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, {
@@ -11910,10 +11957,11 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
     return false;
   }
   LOG.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(loadConfig().machineId) || void 0;
+      const localDaemonIdForDispatch = localCoordinatorDaemonId();
       const sourceCoordinatorSessionId = readNonEmptyString2(task.sourceCoordinatorSessionId) || void 0;
       const dispatchMeshCommand = components.dispatchMeshCommand;
       const remoteDaemonId = node.daemonId;
@@ -11952,7 +12000,7 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
   try {
     const inst = components.instanceManager.getInstance(sessionId);
     if (inst && typeof inst.updateSettings === "function") {
-      const localDaemonId = readNonEmptyString2(loadConfig().machineId);
+      const localDaemonId = localCoordinatorDaemonId();
       const localSourceCoordinatorSessionId = readNonEmptyString2(task.sourceCoordinatorSessionId);
       inst.updateSettings({
         meshNodeFor: meshId,
@@ -11977,7 +12025,7 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
         meshId,
         nodeId,
         taskId: task.id,
-        ...readNonEmptyString2(loadConfig().machineId) ? { coordinatorDaemonId: readNonEmptyString2(loadConfig().machineId) } : {},
+        ...localCoordinatorDaemonId() ? { coordinatorDaemonId: localCoordinatorDaemonId() } : {},
         ...readNonEmptyString2(task.sourceCoordinatorSessionId) ? { coordinatorSessionId: readNonEmptyString2(task.sourceCoordinatorSessionId) } : {}
       }
     }),
@@ -11989,7 +12037,7 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
       task,
       transport: "local",
       ...readNonEmptyString2(task.sourceCoordinatorSessionId) ? { sourceCoordinatorSessionId: readNonEmptyString2(task.sourceCoordinatorSessionId) } : {},
-      ...readNonEmptyString2(loadConfig().machineId) ? { sourceCoordinatorDaemonId: readNonEmptyString2(loadConfig().machineId) } : {}
+      ...localCoordinatorDaemonId() ? { sourceCoordinatorDaemonId: localCoordinatorDaemonId() } : {}
     }
   );
   return true;
@@ -12071,8 +12119,8 @@ function notifyCoordinatorOfActionableSkip(meshId, taskId, reason, nodeId) {
 }
 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) {
@@ -12118,7 +12166,7 @@ function nodeHasActiveMeshWork(components, meshId, nodeId, currentSessionId) {
     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);
@@ -12150,7 +12198,7 @@ function resolveAutoLaunchTarget(components, node) {
   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(loadConfig().machineId);
+  const coordinatorDaemonId = localCoordinatorDaemonId();
   if (!coordinatorDaemonId) return { mode: "skip", reason: "remote_auto_launch_no_coordinator_daemon_id" };
   return { mode: "remote", daemonId, coordinatorDaemonId };
 }
@@ -12161,7 +12209,7 @@ function activeReadonlyAssignedCount(meshId) {
   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);
@@ -12191,7 +12239,7 @@ function orderEligibleNodes(meshId, strategy, nodes, opts) {
   });
 }
 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)) {
@@ -12210,7 +12258,7 @@ function liveSessionCountForNode(components, meshId, nodeId) {
     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;
@@ -12729,6 +12777,7 @@ var init_mesh_queue_assignment = __esm({
     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;
@@ -12829,8 +12878,8 @@ function recordUnroutableDelegateEvent(routing, eventName) {
   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 {
@@ -13092,9 +13141,9 @@ async function updateDarwinMemoryCache() {
     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;
@@ -13321,7 +13370,7 @@ function trimStructuredStrings(value, maxChars) {
   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) {
@@ -13912,9 +13961,9 @@ function readMessageMeta(message) {
 function readStringField(value) {
   return typeof value === "string" ? value.trim().toLowerCase() : "";
 }
-function readRecordField(message, meta, key) {
+function readRecordField(message, meta, key2) {
   const record = message;
-  return record[key] ?? meta?.[key];
+  return record[key2] ?? meta?.[key2];
 }
 function readVisibilityField(message, meta) {
   return readStringField(readRecordField(message, meta, "visibility"));
@@ -13925,7 +13974,7 @@ function readTranscriptVisibilityField(message, meta) {
 }
 function hasBooleanMarker(message, meta, keys) {
   const record = message;
-  return keys.some((key) => record[key] === true || meta?.[key] === true);
+  return keys.some((key2) => record[key2] === true || meta?.[key2] === true);
 }
 function isActivityKind(kind) {
   return kind === "thought" || kind === "tool" || kind === "terminal";
@@ -14117,9 +14166,9 @@ function extractProviderControlValues(controls, data) {
   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;
       }
     }
   }
@@ -14583,26 +14632,26 @@ function getGitSummaryForWorkspace(workspace, options) {
   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;
   }
@@ -16498,9 +16547,9 @@ function recordHeldTerminalEventsToLedger(meshId, drainDaemonIds, reason, heldFo
   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, {
@@ -16521,7 +16570,7 @@ function recordHeldTerminalEventsToLedger(meshId, drainDaemonIds, reason, heldFo
       });
       LOG.info("MeshReconcile", `Ledger-recorded held ${event.event} for mesh ${meshId} (reason ${reason}) \u2014 recoverable from ledger`);
     } catch (e) {
-      heldEventLedgerRecorded.delete(key);
+      heldEventLedgerRecorded.delete(key2);
       LOG.warn("MeshReconcile", `Failed to ledger-record held ${event.event} for mesh ${meshId}: ${e?.message || e}`);
     }
   }
@@ -16986,9 +17035,9 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
   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;
@@ -18575,8 +18624,8 @@ function extractButtonsFromRule(rule, hay) {
         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 {
@@ -18586,8 +18635,8 @@ function extractButtonsFromRule(rule, hay) {
       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);
@@ -18667,12 +18716,12 @@ function evalCond(cond, sections, fullScreen, cursor, prevLines, clock, legacyTr
     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)) {
@@ -22613,16 +22662,16 @@ function normalizeModuleName(request) {
 }
 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;
@@ -22705,10 +22754,10 @@ function _uninstallProviderProcessShimForTest() {
 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 {
     }
   }
@@ -23029,6 +23078,7 @@ __export(index_exports, {
   buildToolChatMessage: () => buildToolChatMessage,
   buildUserChatMessage: () => buildUserChatMessage,
   cancelTask: () => cancelTask,
+  canonicalDaemonId: () => canonicalDaemonId,
   claimNextTask: () => claimNextTask,
   classifyChatMessageVisibility: () => classifyChatMessageVisibility,
   classifyHotChatSessionsForSubscriptionFlush: () => classifyHotChatSessionsForSubscriptionFlush,
@@ -23893,10 +23943,10 @@ var GitWorkspaceMonitor = class {
     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,
@@ -23904,7 +23954,7 @@ var GitWorkspaceMonitor = class {
       timestamp
     };
     const cacheEntry = {
-      key,
+      key: key2,
       workspace: normalized.workspace,
       status,
       diffSummary,
@@ -24048,11 +24098,11 @@ function validateRepoPath(args) {
   }
   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 === "") {
@@ -26464,10 +26514,10 @@ var StatusMonitor = class {
     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;
@@ -26515,16 +26565,16 @@ var savedHistoryBackgroundRefresh = /* @__PURE__ */ new Set();
 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;
@@ -26960,21 +27010,21 @@ function shouldScheduleSavedHistoryRollupForSignature(signature) {
   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;
@@ -26994,7 +27044,7 @@ function scheduleSavedHistoryBackgroundRefresh(agentType, dir) {
       }
     } catch {
     } finally {
-      savedHistoryBackgroundRefresh.delete(key);
+      savedHistoryBackgroundRefresh.delete(key2);
     }
   }, 0);
 }
@@ -27760,14 +27810,14 @@ function rewriteCanonicalSavedHistory(agentType, historySessionId, records) {
     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) {
@@ -28501,11 +28551,11 @@ function validateControlValues(controlValues, source) {
     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;
 }
@@ -29258,7 +29308,7 @@ var DaemonCdpScanner = class {
       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) {
@@ -29432,8 +29482,8 @@ var DaemonCdpInitializer = class {
     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;
         }
@@ -29465,29 +29515,29 @@ var DaemonCdpInitializer = class {
   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);
-      LOG.info("IDE", `Detached window: ${key} (${reason})`);
-      await this.config.onDisconnected?.(ide, manager, key, reason);
+      this.config.cdpManagers.delete(key2);
+      LOG.info("IDE", `Detached window: ${key2} (${reason})`);
+      await this.config.onDisconnected?.(ide, manager, key2, reason);
     }
   }
   // ─── Periodic scanning ───
@@ -29813,7 +29863,7 @@ function sanitizeTraceValue(value, traceContent) {
     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;
@@ -29822,7 +29872,7 @@ function sanitizeTraceValue(value, traceContent) {
   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;
@@ -30130,8 +30180,8 @@ function maxSequence(messages) {
 }
 function isSupersetOf(candidate, required) {
   if (required.size === 0) return true;
-  for (const key of required) {
-    if (!candidate.has(key)) return false;
+  for (const key2 of required) {
+    if (!candidate.has(key2)) return false;
   }
   return true;
 }
@@ -30144,17 +30194,17 @@ function chatSourceSessionKey(providerType, sessionId) {
 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() {
@@ -30166,15 +30216,15 @@ var ChatSourceRegistry = class {
    * 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
@@ -30857,8 +30907,8 @@ function readLiveCodexWorkspaceNativeHistory(agentStr, args) {
   });
   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;
@@ -31028,7 +31078,7 @@ function buildReadChatCommandResult(payload, args, h) {
   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);
   }
@@ -31780,8 +31830,8 @@ function sanitizeDebugBundleValue(value, options = {}, depth = 0, keyHint = "")
   const record = value;
   const result = {};
   const entries = Object.entries(record).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(record).length - entries.length;
   if (remaining > 0) result.__truncatedKeys = remaining;
@@ -32107,14 +32157,14 @@ function callLegacyTextScript(script, text) {
   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) {
@@ -32977,23 +33027,23 @@ async function handleCdpRemoteAction(h, args) {
   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 } : {},
@@ -33001,7 +33051,7 @@ async function handleCdpRemoteAction(h, args) {
           });
           await h.getCdp().send("Input.dispatchKeyEvent", {
             type: "keyUp",
-            key,
+            key: key2,
             code,
             ...vk ? { windowsVirtualKeyCode: vk, nativeVirtualKeyCode: vk } : {},
             ...mod ? { modifiers: mod } : {}
@@ -33400,21 +33450,21 @@ function handleGetProviderSettings(h, args) {
 }
 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);
-      LOG.info("Command", `[set_provider_setting] ${providerType}.${key}=${JSON.stringify(value)} \u2192 ${updated} instance(s) updated`);
+      LOG.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;
@@ -33460,9 +33510,9 @@ function normalizeProviderScriptArgs(args, scriptName) {
       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;
@@ -33862,10 +33912,10 @@ function summarizeCommandArgs(args) {
     "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(" ") : "{...}";
 }
@@ -33917,12 +33967,12 @@ var DaemonCommandHandler = class {
    * 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. */
@@ -33980,11 +34030,11 @@ var DaemonCommandHandler = class {
     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() : "";
@@ -35682,16 +35732,16 @@ var coordinatorPromptHandlers = {
           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 (error) {
@@ -35703,14 +35753,14 @@ var coordinatorPromptHandlers = {
     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 });
@@ -35719,7 +35769,7 @@ var coordinatorPromptHandlers = {
       } else if (fs38.existsSync(full)) {
         fs38.unlinkSync(full);
       }
-      return { success: true, path: full, kind, key };
+      return { success: true, path: full, kind, key: key2 };
     } catch (error) {
       return { success: false, error: error?.message || String(error) };
     }
@@ -36664,7 +36714,7 @@ var RULES = [
   {
     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>
   {
@@ -37014,7 +37064,7 @@ function realWorkspacePath(workingDir) {
 }
 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 = {};
@@ -37027,18 +37077,18 @@ function applyPreLaunchTrust(trust, workingDir) {
         }
       }
     }
-    const existing = parsed[key];
+    const existing = parsed[key2];
     const list = Array.isArray(existing) ? existing.filter((v) => typeof v === "string") : [];
     if (list.includes(real)) {
       LOG.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(path22.dirname(settingsPath), { recursive: true });
     fs14.writeFileSync(settingsPath, `${JSON.stringify(parsed, null, 2)}
 `, "utf8");
-    LOG.info("pre-launch-trust", `pre-trusted workspace in ${trust.settings_path} (key="${key}")`);
+    LOG.info("pre-launch-trust", `pre-trusted workspace in ${trust.settings_path} (key="${key2}")`);
     return real;
   } catch (err) {
     LOG.warn("pre-launch-trust", `failed to pre-trust workspace in ${trust.settings_path}: ${err.message}`);
@@ -38649,8 +38699,8 @@ function jsonPathGet(record, expr) {
     }
     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;
@@ -40625,8 +40675,8 @@ var CliProviderInstance = class _CliProviderInstance {
   /** 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() {
@@ -41830,8 +41880,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) => {
@@ -43436,16 +43486,16 @@ var DEFAULT_COORDINATOR_DELEGATED_ENV_UNSETS = [
 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;
@@ -43462,10 +43512,10 @@ function buildCoordinatorDelegatedCliLaunchOptions(input) {
   const cliArgs = Array.isArray(input.cliArgs) ? [...input.cliArgs] : [];
   const env = { ...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) env[key] = "";
+  for (const key2 of envUnsets) env[key2] = "";
   for (const rule of input.isolation?.args || []) {
     if (!rule || typeof rule !== "object") continue;
     if (rule.mode === "empty_mcp_config") {
@@ -43478,9 +43528,9 @@ function buildCoordinatorDelegatedCliLaunchOptions(input) {
       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}`);
     }
   }
@@ -43686,12 +43736,12 @@ var DaemonCliManager = class {
     }
     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;
@@ -43700,12 +43750,12 @@ var DaemonCliManager = class {
         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);
               LOG.info("CLI", `\u{1F9F9} Auto-cleaned ${status.status} CLI: ${cliType}`);
               this.deps.onStatusChange();
             }
@@ -43715,21 +43765,21 @@ var DaemonCliManager = class {
       }
     }, 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) => {
@@ -43741,8 +43791,8 @@ var DaemonCliManager = class {
         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.
@@ -43758,10 +43808,10 @@ var DaemonCliManager = class {
       });
     } catch (spawnErr) {
       LOG.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) {
@@ -43774,7 +43824,7 @@ var DaemonCliManager = class {
       } catch {
       }
     }
-    this.startCliExitMonitor(key, cliType);
+    this.startCliExitMonitor(key2, cliType);
   }
   // ─── Session start/management ──────────────────────────────
   async startSession(cliType, workingDir, cliArgs, initialModel, options) {
@@ -43791,11 +43841,11 @@ var DaemonCliManager = class {
 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;
@@ -43815,7 +43865,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();
@@ -43824,11 +43874,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,
@@ -43836,7 +43886,7 @@ ${installInfo}`
         spawn: async () => {
         },
         shutdown: () => {
-          instanceManager2.removeInstance(key);
+          instanceManager2.removeInstance(key2);
         },
         sendMessage: async (text) => {
           const input = normalizeInputEnvelope(text);
@@ -43852,7 +43902,7 @@ ${installInfo}`
         },
         getPartialResponse: () => "",
         cancel: () => {
-          instanceManager2.removeInstance(key);
+          instanceManager2.removeInstance(key2);
         },
         isProcessing: () => false,
         isReady: () => true,
@@ -43906,7 +43956,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,
@@ -43936,7 +43986,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         cliType,
         resolvedDir,
         resolvedCliArgs,
-        key,
+        key2,
         sessionBinding.providerSessionId,
         false,
         options?.extraEnv
@@ -43956,9 +44006,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);
               LOG.info("CLI", `\u{1F9F9} Auto-cleaned ${status.status} CLI: ${adapter.cliType}`);
               this.deps.onStatusChange();
             }
@@ -43967,10 +44017,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({
@@ -43980,20 +44030,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") {
@@ -44004,21 +44054,21 @@ Run 'adhdev doctor' for detailed diagnostics.`
       } catch (e) {
         LOG.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);
       LOG.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);
-        LOG.warn("CLI", `\u{1F9F9} Force-removed orphan entry: ${key}`);
+        this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key2);
+        im.removeInstance(key2);
+        this.deps.removeAgentTracking(key2);
+        unregisterMeshCoordinator(key2);
+        LOG.warn("CLI", `\u{1F9F9} Force-removed orphan entry: ${key2}`);
         this.deps.onStatusChange();
       }
     }
@@ -44046,8 +44096,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 record of sessions) {
       if (!record?.runtimeId || !record?.cliType || !record?.workspace) continue;
@@ -44401,7 +44451,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)) {
@@ -44411,7 +44461,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,
@@ -44443,7 +44493,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,
@@ -44455,7 +44505,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}`);
@@ -44727,9 +44777,9 @@ function validateProviderDefinition(raw) {
   } 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) {
@@ -44874,10 +44924,10 @@ function validateNativeHistory(raw, errors) {
     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`);
     }
   }
 }
@@ -44912,10 +44962,10 @@ function validateMeshCoordinatorMcpConfig(mcpConfig, errors) {
   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 = config[key];
+  for (const key2 of ["path", "serverName", "configPathCommand", "instructions", "template"]) {
+    const value = config[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 (config.requiresRestart !== void 0 && typeof config.requiresRestart !== "boolean") {
@@ -44951,7 +45001,7 @@ function validateMeshCoordinatorDelegatedWorkerIsolation(raw, errors) {
       errors.push("meshCoordinator.delegatedWorkerIsolation.env must be an object");
     } else {
       const unset = env.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");
       }
     }
@@ -44974,16 +45024,16 @@ function validateMeshCoordinatorDelegatedWorkerIsolation(raw, errors) {
       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`);
       }
     }
   }
@@ -47206,9 +47256,9 @@ var ProviderLoader = class _ProviderLoader {
   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();
@@ -47516,7 +47566,7 @@ var ProviderLoader = class _ProviderLoader {
   */
   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
@@ -47532,23 +47582,23 @@ var ProviderLoader = class _ProviderLoader {
   /**
   * 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 config = this.readConfig();
-    const userVal = config?.providerSettings?.[providerType]?.[key];
+    const userVal = config?.providerSettings?.[providerType]?.[key2];
     return userVal !== void 0 ? userVal : defaultVal;
   }
   /**
@@ -47558,17 +47608,17 @@ var ProviderLoader = class _ProviderLoader {
     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;
@@ -47579,13 +47629,13 @@ var ProviderLoader = class _ProviderLoader {
       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
       });
@@ -47595,17 +47645,17 @@ var ProviderLoader = class _ProviderLoader {
     try {
       if (!config.providerSettings) config.providerSettings = {};
       if (!config.providerSettings[providerType]) config.providerSettings[providerType] = {};
-      config.providerSettings[providerType][key] = value;
+      config.providerSettings[providerType][key2] = value;
       this.writeConfig(config);
-      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;
@@ -47785,7 +47835,7 @@ var ProviderLoader = class _ProviderLoader {
           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("`")) {
@@ -47794,7 +47844,7 @@ var ProviderLoader = class _ProviderLoader {
                 } 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") {
@@ -49546,9 +49596,20 @@ var meshQueueHandlers = {
         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 };
@@ -51079,15 +51140,15 @@ var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
 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;
@@ -52184,23 +52245,23 @@ var MeshGitProbeCache = class {
    * 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);
     }
   }
 };
@@ -54898,8 +54959,8 @@ var DaemonCommandRouter = class {
           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;
           LOG.info("Mesh", `[Refinery] Auto-resuming interrupted refine job for node ${e.nodeId} (jobId=${jobId})`);
           void this.startMeshRefineJob(meshId, e.nodeId, {
@@ -55982,7 +56043,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);
@@ -56014,8 +56075,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);
@@ -56039,8 +56100,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;
@@ -56055,7 +56116,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(() => {
@@ -56070,7 +56131,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);
@@ -56138,17 +56199,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));
@@ -56156,7 +56217,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(() => {
@@ -56212,27 +56273,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);
-        LOG.info("StopIDE", `CDP disconnected: ${key}`);
+        this.deps.cdpManagers.delete(key2);
+        this.deps.sessionRegistry.unregisterByManagerKey(key2);
+        LOG.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) {
@@ -60925,9 +60986,9 @@ async function handleAutoImplement(ctx, type, req, res) {
       }
       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" } });
@@ -62179,8 +62240,8 @@ var DevServer = class _DevServer {
       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,
@@ -62500,16 +62561,16 @@ var DevServer = class _DevServer {
       errors.push(...validation.errors);
       warnings.push(...validation.warnings);
       if (config.settings) {
-        for (const [key, val] of Object.entries(config.settings)) {
+        for (const [key2, val] of Object.entries(config.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 (config.cdpPorts && Array.isArray(config.cdpPorts)) {
@@ -63293,21 +63354,21 @@ function isLowercaseLetter(value) {
 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));
@@ -63316,7 +63377,7 @@ function namedKeyToAnsi(key) {
     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");
@@ -63794,19 +63855,19 @@ var SessionRegistry = class {
     if (!ids) return [];
     return [...ids].map((id) => this.bySessionId.get(id)).filter(Boolean);
   }
-  addIndex(index, key, sessionId) {
-    let set = index.get(key);
+  addIndex(index, key2, sessionId) {
+    let set = index.get(key2);
     if (!set) {
       set = /* @__PURE__ */ new Set();
-      index.set(key, set);
+      index.set(key2, set);
     }
     set.add(sessionId);
   }
-  removeIndex(index, key, sessionId) {
-    const set = index.get(key);
+  removeIndex(index, key2, sessionId) {
+    const set = index.get(key2);
     if (!set) return;
     set.delete(sessionId);
-    if (set.size === 0) index.delete(key);
+    if (set.size === 0) index.delete(key2);
   }
 };
@@ -64467,6 +64528,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   buildToolChatMessage,
   buildUserChatMessage,
   cancelTask,
+  canonicalDaemonId,
   claimNextTask,
   classifyChatMessageVisibility,
   classifyHotChatSessionsForSubscriptionFlush,