@adhdev/daemon-core 0.9.82-rc.412 → 0.9.82-rc.413

package/dist/index.mjs

@@ -17,9 +17,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;
 };
@@ -384,10 +384,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.413" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-28T11:48:26.300Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -408,18 +408,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 };
 }
@@ -446,20 +446,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 };
@@ -788,12 +788,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" };
@@ -2355,9 +2355,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,
@@ -2374,9 +2374,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,
@@ -2440,11 +2440,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,
@@ -3147,6 +3147,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);
@@ -3311,8 +3317,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) {
@@ -4711,6 +4717,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, {
@@ -4978,14 +5011,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) {
@@ -5204,6 +5237,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;
   });
@@ -5228,6 +5262,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;
   });
@@ -5237,6 +5272,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) {
@@ -5281,6 +5321,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`;
@@ -5324,6 +5365,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;
   });
@@ -5437,6 +5479,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"];
@@ -7502,7 +7545,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) } : {},
@@ -7771,7 +7814,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(
@@ -7780,9 +7823,9 @@ function replaceLegacyCliCommandMcpArgs(command, args) {
   );
 }
 function resolveHermesCoordinatorHome(meshId, workspace) {
-  const key = `${meshId || "mesh"}
+  const key2 = `${meshId || "mesh"}
 ${resolve7(workspace || os4.tmpdir())}`;
-  const hash = shortHash(key);
+  const hash = shortHash(key2);
   return join10(os4.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
 }
 function resolveMcpConfigPath(configPath, workspace) {
@@ -8252,9 +8295,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 {
@@ -11748,6 +11791,9 @@ var init_mesh_warmup_deadline = __esm({
 
 // src/mesh/mesh-queue-assignment.ts
 import { existsSync as existsSync17 } from "fs";
+function localCoordinatorDaemonId() {
+  return canonicalDaemonId(readNonEmptyString2(loadConfig().machineId));
+}
 function __resetIdleAutoFastForwardForTests() {
   idleAutoFastForwardLastAttempt.clear();
 }
@@ -11833,6 +11879,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, {
@@ -11906,10 +11953,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;
@@ -11948,7 +11996,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,
@@ -11973,7 +12021,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) } : {}
       }
     }),
@@ -11985,7 +12033,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;
@@ -12067,8 +12115,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) {
@@ -12114,7 +12162,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);
@@ -12146,7 +12194,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 };
 }
@@ -12157,7 +12205,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);
@@ -12187,7 +12235,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)) {
@@ -12206,7 +12254,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;
@@ -12724,6 +12772,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;
@@ -12824,8 +12873,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 {
@@ -13090,9 +13139,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;
@@ -13316,7 +13365,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) {
@@ -13907,9 +13956,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"));
@@ -13920,7 +13969,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";
@@ -14112,9 +14161,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;
       }
     }
   }
@@ -14578,26 +14627,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;
   }
@@ -16493,9 +16542,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, {
@@ -16516,7 +16565,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}`);
     }
   }
@@ -16981,9 +17030,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;
@@ -18569,8 +18618,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 {
@@ -18580,8 +18629,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);
@@ -18661,12 +18710,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)) {
@@ -22610,16 +22659,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;
@@ -22702,10 +22751,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 {
     }
   }
@@ -23510,10 +23559,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,
@@ -23521,7 +23570,7 @@ var GitWorkspaceMonitor = class {
       timestamp
     };
     const cacheEntry = {
-      key,
+      key: key2,
       workspace: normalized.workspace,
       status,
       diffSummary,
@@ -23665,11 +23714,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 === "") {
@@ -26081,10 +26130,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;
@@ -26132,16 +26181,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;
@@ -26577,21 +26626,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;
@@ -26611,7 +26660,7 @@ function scheduleSavedHistoryBackgroundRefresh(agentType, dir) {
       }
     } catch {
     } finally {
-      savedHistoryBackgroundRefresh.delete(key);
+      savedHistoryBackgroundRefresh.delete(key2);
     }
   }, 0);
 }
@@ -27377,14 +27426,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) {
@@ -28118,11 +28167,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;
 }
@@ -28875,7 +28924,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) {
@@ -29049,8 +29098,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;
         }
@@ -29082,29 +29131,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 ───
@@ -29430,7 +29479,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;
@@ -29439,7 +29488,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;
@@ -29747,8 +29796,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;
 }
@@ -29761,17 +29810,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() {
@@ -29783,15 +29832,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
@@ -30474,8 +30523,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;
@@ -30645,7 +30694,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);
   }
@@ -31397,8 +31446,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;
@@ -31724,14 +31773,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) {
@@ -32594,23 +32643,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 } : {},
@@ -32618,7 +32667,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 } : {}
@@ -33017,21 +33066,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;
@@ -33077,9 +33126,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;
@@ -33479,10 +33528,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(" ") : "{...}";
 }
@@ -33534,12 +33583,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. */
@@ -33597,11 +33646,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() : "";
@@ -35299,16 +35348,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) {
@@ -35320,14 +35369,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 });
@@ -35336,7 +35385,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) };
     }
@@ -36281,7 +36330,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>
   {
@@ -36631,7 +36680,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 = {};
@@ -36644,18 +36693,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}`);
@@ -38266,8 +38315,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;
@@ -40242,8 +40291,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() {
@@ -41447,8 +41496,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) => {
@@ -43058,16 +43107,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;
@@ -43084,10 +43133,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") {
@@ -43100,9 +43149,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}`);
     }
   }
@@ -43308,12 +43357,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;
@@ -43322,12 +43371,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();
             }
@@ -43337,21 +43386,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) => {
@@ -43363,8 +43412,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.
@@ -43380,10 +43429,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) {
@@ -43396,7 +43445,7 @@ var DaemonCliManager = class {
       } catch {
       }
     }
-    this.startCliExitMonitor(key, cliType);
+    this.startCliExitMonitor(key2, cliType);
   }
   // ─── Session start/management ──────────────────────────────
   async startSession(cliType, workingDir, cliArgs, initialModel, options) {
@@ -43413,11 +43462,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;
@@ -43437,7 +43486,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();
@@ -43446,11 +43495,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,
@@ -43458,7 +43507,7 @@ ${installInfo}`
         spawn: async () => {
         },
         shutdown: () => {
-          instanceManager2.removeInstance(key);
+          instanceManager2.removeInstance(key2);
         },
         sendMessage: async (text) => {
           const input = normalizeInputEnvelope(text);
@@ -43474,7 +43523,7 @@ ${installInfo}`
         },
         getPartialResponse: () => "",
         cancel: () => {
-          instanceManager2.removeInstance(key);
+          instanceManager2.removeInstance(key2);
         },
         isProcessing: () => false,
         isReady: () => true,
@@ -43528,7 +43577,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,
@@ -43558,7 +43607,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         cliType,
         resolvedDir,
         resolvedCliArgs,
-        key,
+        key2,
         sessionBinding.providerSessionId,
         false,
         options?.extraEnv
@@ -43578,9 +43627,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();
             }
@@ -43589,10 +43638,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({
@@ -43602,20 +43651,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") {
@@ -43626,21 +43675,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();
       }
     }
@@ -43668,8 +43717,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;
@@ -44023,7 +44072,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)) {
@@ -44033,7 +44082,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,
@@ -44065,7 +44114,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,
@@ -44077,7 +44126,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}`);
@@ -44349,9 +44398,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) {
@@ -44496,10 +44545,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`);
     }
   }
 }
@@ -44534,10 +44583,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") {
@@ -44573,7 +44622,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");
       }
     }
@@ -44596,16 +44645,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`);
       }
     }
   }
@@ -46828,9 +46877,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();
@@ -47138,7 +47187,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
@@ -47154,23 +47203,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;
   }
   /**
@@ -47180,17 +47229,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;
@@ -47201,13 +47250,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
       });
@@ -47217,17 +47266,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;
@@ -47407,7 +47456,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("`")) {
@@ -47416,7 +47465,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") {
@@ -49168,9 +49217,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 };
@@ -50701,15 +50761,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;
@@ -51806,23 +51866,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);
     }
   }
 };
@@ -54520,8 +54580,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, {
@@ -55604,7 +55664,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);
@@ -55636,8 +55696,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);
@@ -55661,8 +55721,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;
@@ -55677,7 +55737,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(() => {
@@ -55692,7 +55752,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);
@@ -55760,17 +55820,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));
@@ -55778,7 +55838,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(() => {
@@ -55834,27 +55894,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) {
@@ -60547,9 +60607,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" } });
@@ -61801,8 +61861,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,
@@ -62122,16 +62182,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)) {
@@ -62919,21 +62979,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));
@@ -62942,7 +63002,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");
@@ -63423,19 +63483,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);
   }
 };
 
@@ -64095,6 +64155,7 @@ export {
   buildToolChatMessage,
   buildUserChatMessage,
   cancelTask,
+  canonicalDaemonId,
   claimNextTask,
   classifyChatMessageVisibility,
   classifyHotChatSessionsForSubscriptionFlush,