@adhdev/daemon-standalone 0.9.82-rc.411 → 0.9.82-rc.413

package/dist/index.js

@@ -29727,9 +29727,9 @@ var require_dist3 = __commonJS({
     };
     var __copyProps2 = (to, from, except, desc) => {
       if (from && typeof from === "object" || typeof from === "function") {
-        for (let key of __getOwnPropNames2(from))
-          if (!__hasOwnProp2.call(to, key) && key !== except)
-            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+        for (let key2 of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key2) && key2 !== except)
+            __defProp2(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc2(from, key2)) || desc.enumerable });
       }
       return to;
     };
@@ -29747,14 +29747,6 @@ var require_dist3 = __commonJS({
       const trimmed = value.trim();
       return MESH_SCHEDULING_STRATEGIES.includes(trimmed) ? trimmed : DEFAULT_MESH_SCHEDULING_STRATEGY;
     }
-    function normalizeMeshDistribution(value) {
-      if (typeof value !== "string") return DEFAULT_MESH_DISTRIBUTION;
-      const trimmed = value.trim();
-      return MESH_DISTRIBUTIONS.includes(trimmed) ? trimmed : DEFAULT_MESH_DISTRIBUTION;
-    }
-    function distributionToStrategy(distribution) {
-      return distribution === "spread" ? "least_loaded" : "first_eligible";
-    }
     function resolveNodeSchedulingPriority(nodePolicy) {
       const raw = Number(nodePolicy?.schedulingPriority);
       return Number.isFinite(raw) ? raw : 0;
@@ -29843,8 +29835,6 @@ var require_dist3 = __commonJS({
     }
     var MESH_SCHEDULING_STRATEGIES;
     var DEFAULT_MESH_SCHEDULING_STRATEGY;
-    var MESH_DISTRIBUTIONS;
-    var DEFAULT_MESH_DISTRIBUTION;
     var MESH_CONVERGE_REFINE_TAG;
     var MESH_CONVERGE_FAST_FORWARD_TAG;
     var DEFAULT_MESH_POLICY;
@@ -29864,8 +29854,6 @@ var require_dist3 = __commonJS({
           "priority_only"
         ];
         DEFAULT_MESH_SCHEDULING_STRATEGY = "first_eligible";
-        MESH_DISTRIBUTIONS = ["spread", "in_order"];
-        DEFAULT_MESH_DISTRIBUTION = "spread";
         MESH_CONVERGE_REFINE_TAG = "converge=refine";
         MESH_CONVERGE_FAST_FORWARD_TAG = "converge=fast_forward";
         DEFAULT_MESH_POLICY = {
@@ -30127,10 +30115,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "69cd9c459ec9efafe19a05f66899bb791d6e0561" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "69cd9c45" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.411" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-28T09:11:57.766Z" : void 0);
+      const commit = readInjected(true ? "7a774e95a82354f5357197b3c84f63e68b5f7a5d" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "7a774e95" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.413" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-28T11:49:09.563Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -30146,18 +30134,18 @@ var require_dist3 = __commonJS({
     function isStringArray(value) {
       return Array.isArray(value) && value.every((v) => typeof v === "string" && v.length > 0);
     }
-    function validateTarget(value, key, errors) {
+    function validateTarget(value, key2, errors) {
       if (!isRecord(value)) {
-        errors.push(`impactTargets.${key} must be an object`);
+        errors.push(`impactTargets.${key2} must be an object`);
         return void 0;
       }
       const { recommendedCommand } = value;
       if (typeof recommendedCommand !== "string" || !recommendedCommand.length) {
-        errors.push(`impactTargets.${key}.recommendedCommand must be a non-empty string`);
+        errors.push(`impactTargets.${key2}.recommendedCommand must be a non-empty string`);
         return void 0;
       }
       for (const k of Object.keys(value)) {
-        if (k !== "recommendedCommand") errors.push(`impactTargets.${key}.${k} is not a recognized field (only recommendedCommand)`);
+        if (k !== "recommendedCommand") errors.push(`impactTargets.${key2}.${k} is not a recognized field (only recommendedCommand)`);
       }
       return { recommendedCommand };
     }
@@ -30184,20 +30172,20 @@ var require_dist3 = __commonJS({
           errors.push("impactTargets must be an object");
         } else {
           const targets = {};
-          for (const key of Object.keys(raw.impactTargets)) {
-            if (key !== "daemon" && key !== "web" && key !== "none") {
-              errors.push(`impactTargets.${key} is not a recognized impact kind (daemon|web|none)`);
+          for (const key2 of Object.keys(raw.impactTargets)) {
+            if (key2 !== "daemon" && key2 !== "web" && key2 !== "none") {
+              errors.push(`impactTargets.${key2} is not a recognized impact kind (daemon|web|none)`);
               continue;
             }
-            const target = validateTarget(raw.impactTargets[key], key, errors);
-            if (target) targets[key] = target;
+            const target = validateTarget(raw.impactTargets[key2], key2, errors);
+            if (target) targets[key2] = target;
           }
           if (Object.keys(targets).length) config2.impactTargets = targets;
         }
       }
-      for (const key of Object.keys(raw)) {
-        if (!["daemonRuntimePackages", "webOnlyPackages", "nonRuntimeRootFilePatterns", "impactTargets"].includes(key)) {
-          errors.push(`unknown config key '${key}'`);
+      for (const key2 of Object.keys(raw)) {
+        if (!["daemonRuntimePackages", "webOnlyPackages", "nonRuntimeRootFilePatterns", "impactTargets"].includes(key2)) {
+          errors.push(`unknown config key '${key2}'`);
         }
       }
       return { valid: errors.length === 0, errors, config: errors.length === 0 ? config2 : void 0 };
@@ -30531,12 +30519,12 @@ var require_dist3 = __commonJS({
         return { config: null, sourceKey: "forced-default" };
       }
       if (options.changeImpactConfig !== void 0) {
-        let key = "injected";
+        let key2 = "injected";
         try {
-          key = `injected:${JSON.stringify(options.changeImpactConfig)}`;
+          key2 = `injected:${JSON.stringify(options.changeImpactConfig)}`;
         } catch {
         }
-        return { config: options.changeImpactConfig, sourceKey: key };
+        return { config: options.changeImpactConfig, sourceKey: key2 };
       }
       if (!repoRoot) {
         return { config: null, sourceKey: "no-repo-root" };
@@ -32115,9 +32103,9 @@ ${error48.message || ""}`;
       ].filter(Boolean)));
       const nextSessionNotificationDismissals = { ...state.sessionNotificationDismissals || {} };
       const nextSessionNotificationUnreadOverrides = { ...state.sessionNotificationUnreadOverrides || {} };
-      for (const key of dismissalKeys) {
-        nextSessionNotificationDismissals[key] = dismissalId;
-        delete nextSessionNotificationUnreadOverrides[key];
+      for (const key2 of dismissalKeys) {
+        nextSessionNotificationDismissals[key2] = dismissalId;
+        delete nextSessionNotificationUnreadOverrides[key2];
       }
       return {
         ...state,
@@ -32134,9 +32122,9 @@ ${error48.message || ""}`;
       ].filter(Boolean)));
       const nextSessionNotificationDismissals = { ...state.sessionNotificationDismissals || {} };
       const nextSessionNotificationUnreadOverrides = { ...state.sessionNotificationUnreadOverrides || {} };
-      for (const key of unreadKeys) {
-        nextSessionNotificationUnreadOverrides[key] = unreadId;
-        delete nextSessionNotificationDismissals[key];
+      for (const key2 of unreadKeys) {
+        nextSessionNotificationUnreadOverrides[key2] = unreadId;
+        delete nextSessionNotificationDismissals[key2];
       }
       return {
         ...state,
@@ -32200,11 +32188,11 @@ ${error48.message || ""}`;
       const nextSessionReadMarkers = { ...prevMarkers };
       const nextSessionNotificationDismissals = { ...state.sessionNotificationDismissals || {} };
       const nextSessionNotificationUnreadOverrides = { ...state.sessionNotificationUnreadOverrides || {} };
-      for (const key of readKeys) {
-        nextSessionReads[key] = Math.max(prev[key] || 0, seenAt);
-        if (nextMarker) nextSessionReadMarkers[key] = nextMarker;
-        delete nextSessionNotificationDismissals[key];
-        delete nextSessionNotificationUnreadOverrides[key];
+      for (const key2 of readKeys) {
+        nextSessionReads[key2] = Math.max(prev[key2] || 0, seenAt);
+        if (nextMarker) nextSessionReadMarkers[key2] = nextMarker;
+        delete nextSessionNotificationDismissals[key2];
+        delete nextSessionNotificationUnreadOverrides[key2];
       }
       return {
         ...state,
@@ -32905,6 +32893,12 @@ ${error48.message || ""}`;
       }
       return trimmed;
     }
+    function canonicalDaemonId(id) {
+      const core = machineCoreFromDaemonId(id);
+      if (!core) return void 0;
+      if (!core.startsWith("mach_")) return core;
+      return `daemon_${core}`;
+    }
     function daemonIdsEquivalent(a, b) {
       const coreA = machineCoreFromDaemonId(a);
       const coreB = machineCoreFromDaemonId(b);
@@ -33064,8 +33058,8 @@ Default branch: \`${mesh.defaultBranch}\`` : ""}`);
         rules: buildRulesSection(coordinatorCliType),
         toolExposurePreflight: TOOL_EXPOSURE_PREFLIGHT_SECTION
       };
-      return template.replace(/\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g, (m, key) => {
-        return Object.prototype.hasOwnProperty.call(replacements, key) ? replacements[key] : m;
+      return template.replace(/\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g, (m, key2) => {
+        return Object.prototype.hasOwnProperty.call(replacements, key2) ? replacements[key2] : m;
       });
     }
     function buildNodeStatusSection(nodes) {
@@ -34505,6 +34499,31 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         ]);
       }
     });
+    function key(meshId, taskId) {
+      return `${meshId}::${taskId}`;
+    }
+    function beginTaskDispatchInFlight(meshId, taskId) {
+      if (!meshId || !taskId) return false;
+      const k = key(meshId, taskId);
+      if (inFlight.has(k)) return false;
+      inFlight.add(k);
+      return true;
+    }
+    function isTaskDispatchInFlight(meshId, taskId) {
+      if (!meshId || !taskId) return false;
+      return inFlight.has(key(meshId, taskId));
+    }
+    function endTaskDispatchInFlight(meshId, taskId) {
+      if (!meshId || !taskId) return;
+      inFlight.delete(key(meshId, taskId));
+    }
+    var inFlight;
+    var init_mesh_task_inflight = __esm2({
+      "src/mesh/mesh-task-inflight.ts"() {
+        "use strict";
+        inFlight = /* @__PURE__ */ new Set();
+      }
+    });
     var mesh_work_queue_exports = {};
     __export2(mesh_work_queue_exports, {
       ACTIVE_MESH_QUEUE_STATUSES: () => ACTIVE_MESH_QUEUE_STATUSES,
@@ -34770,14 +34789,14 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       if (!Array.isArray(raw)) return void 0;
       return raw.find((type) => typeof type === "string" && type.trim())?.trim();
     }
-    function readNodeOverride(node, key) {
+    function readNodeOverride(node, key2) {
       const overrides = node?.userOverrides;
       if (!overrides || typeof overrides !== "object" || Array.isArray(overrides)) return null;
-      const value = overrides[key];
+      const value = overrides[key2];
       return typeof value === "string" && value.trim() ? value.trim() : null;
     }
-    function readNodeReporter(node, key) {
-      const value = key === "platform" ? node?.reportedPlatform : node?.reportedArch;
+    function readNodeReporter(node, key2) {
+      const value = key2 === "platform" ? node?.reportedPlatform : node?.reportedArch;
       return typeof value === "string" && value.trim() ? value.trim() : null;
     }
     function buildMeshNodeCapabilityTags(node, providerType) {
@@ -34996,6 +35015,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         if (!entry) return null;
         entry.status = status;
         MeshRuntimeStore.getInstance().updateQueueEntry(entry);
+        if (status !== "assigned") endTaskDispatchInFlight(meshId, taskId);
         if (DEPENDENCY_FAILURE_TERMINALS.has(status)) propagateDependencyFailure(meshId, taskId);
         return entry;
       });
@@ -35020,6 +35040,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         entry.cancelledAt = now;
         if (opts?.reason) entry.cancelReason = opts.reason;
         MeshRuntimeStore.getInstance().updateQueueEntry(entry);
+        endTaskDispatchInFlight(meshId, taskId);
         propagateDependencyFailure(meshId, taskId);
         return entry;
       });
@@ -35029,6 +35050,11 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       return withQueueLock(meshId, () => {
         const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
         if (!entry) return null;
+        if (!opts?.force && isTaskDispatchInFlight(meshId, taskId)) {
+          LOG2.warn("MeshQueue", `Refusing to requeue task ${taskId} on mesh ${meshId}: it is actively dispatched/generating (single-flight in-flight). Requeueing now would open a duplicate second dispatch into another session. Pass force to override.`);
+          return entry;
+        }
+        endTaskDispatchInFlight(meshId, taskId);
         const currentCount = entry.requeueCount || 0;
         const maxRetries = opts?.maxRetries ?? entry.maxRetries ?? 1;
         if (!opts?.force && currentCount >= maxRetries) {
@@ -35073,6 +35099,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         delete entry.dispatchTimestamp;
         entry.strandedReclaimCount = reclaims;
         entry.updatedAt = now;
+        endTaskDispatchInFlight(meshId, taskId);
         if (reclaims > MAX_STRANDED_RECLAIMS) {
           entry.status = "failed";
           entry.cancelReason = `stranded_dispatch_unrecovered: reclaimed ${reclaims - 1} time(s) without a confirmed dispatch`;
@@ -35116,6 +35143,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         }
         entry.status = status;
         store.updateQueueEntry(entry);
+        if (status !== "assigned") endTaskDispatchInFlight(meshId, entry.id);
         if (DEPENDENCY_FAILURE_TERMINALS.has(status)) propagateDependencyFailure(meshId, entry.id);
         return entry;
       });
@@ -35240,6 +35268,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         init_logger();
         init_mesh_ledger();
         init_mesh_delivery_policy();
+        init_mesh_task_inflight();
         ACTIVE_MESH_QUEUE_STATUSES = ["pending", "assigned"];
         HISTORICAL_MESH_QUEUE_STATUSES = ["completed", "failed", "cancelled"];
         MESH_TASK_MODES = ["code_change", "validation", "live_debug_readonly", "launch_app", "convergence"];
@@ -36882,6 +36911,9 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       summarizeMissionTasks: () => summarizeMissionTasks,
       upsertMeshMission: () => upsertMeshMission
     });
+    function summarizeGoalForLedger(goal) {
+      return goal.length > LEDGER_GOAL_SUMMARY_MAX ? goal.slice(0, LEDGER_GOAL_SUMMARY_MAX) : goal;
+    }
     function normalizeMissionStatus(value) {
       return MESH_MISSION_STATUSES.includes(value) ? value : "active";
     }
@@ -36894,6 +36926,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       const id = typeof input.id === "string" && input.id.trim() ? input.id.trim() : (0, import_crypto7.randomUUID)();
       const store = MeshRuntimeStore.getInstance();
       const existing = store.getMission(meshId, id);
+      const prevStatus = existing ? normalizeMissionStatus(existing.status) : null;
+      const prevGoal = existing?.goal ?? "";
       const record2 = {
         id,
         meshId,
@@ -36903,7 +36937,61 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       };
       store.upsertMission(record2);
       const saved = store.getMission(meshId, id);
-      return { ...saved, status: normalizeMissionStatus(saved.status) };
+      const result = { ...saved, status: normalizeMissionStatus(saved.status) };
+      appendMissionLedgerEntries(meshId, {
+        isCreate: !existing,
+        record: result,
+        prevStatus,
+        prevGoal
+      });
+      return result;
+    }
+    function appendMissionLedgerEntries(meshId, args) {
+      const { isCreate, record: record2, prevStatus, prevGoal } = args;
+      try {
+        if (isCreate) {
+          const goal = record2.goal ?? "";
+          appendLedgerEntry(meshId, {
+            kind: "mission_created",
+            payload: {
+              missionId: record2.id,
+              title: record2.title,
+              goalSummary: summarizeGoalForLedger(goal),
+              goalLength: goal.length,
+              goalTruncated: goal.length > LEDGER_GOAL_SUMMARY_MAX,
+              status: record2.status
+            }
+          });
+          return;
+        }
+        if (prevStatus !== null && prevStatus !== record2.status) {
+          appendLedgerEntry(meshId, {
+            kind: "mission_status_changed",
+            payload: {
+              missionId: record2.id,
+              title: record2.title,
+              fromStatus: prevStatus,
+              toStatus: record2.status
+            }
+          });
+        }
+        const nextGoal = record2.goal ?? "";
+        if (nextGoal !== prevGoal) {
+          appendLedgerEntry(meshId, {
+            kind: "mission_goal_updated",
+            payload: {
+              missionId: record2.id,
+              title: record2.title,
+              prevGoalSummary: summarizeGoalForLedger(prevGoal),
+              nextGoalSummary: summarizeGoalForLedger(nextGoal),
+              prevGoalLength: prevGoal.length,
+              nextGoalLength: nextGoal.length,
+              goalTruncated: prevGoal.length > LEDGER_GOAL_SUMMARY_MAX || nextGoal.length > LEDGER_GOAL_SUMMARY_MAX
+            }
+          });
+        }
+      } catch {
+      }
     }
     function getMeshMissions(meshId, statuses) {
       return MeshRuntimeStore.getInstance().getMissions(meshId, statuses).map((m) => ({ ...m, status: normalizeMissionStatus(m.status) }));
@@ -37008,6 +37096,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       return lines.join("\n");
     }
     var import_crypto7;
+    var LEDGER_GOAL_SUMMARY_MAX;
     var MESH_MISSION_STATUSES;
     var GOAL_PREVIEW_MAX;
     var COMPACT_STATUS_GOAL_PREVIEW_MAX;
@@ -37018,6 +37107,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
         init_mesh_runtime_store();
         init_mesh_work_queue();
         init_mesh_task_stats();
+        init_mesh_ledger();
+        LEDGER_GOAL_SUMMARY_MAX = 200;
         MESH_MISSION_STATUSES = ["active", "paused", "completed", "abandoned"];
         GOAL_PREVIEW_MAX = 120;
         COMPACT_STATUS_GOAL_PREVIEW_MAX = 80;
@@ -37243,7 +37334,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
               timestamp: entry.timestamp,
               ...entry.sessionId ? { sessionId: entry.sessionId } : {},
               bootstrap: readRecord3(validationSummary?.bootstrap),
-              validation: validationSummary ? Object.fromEntries(Object.entries(validationSummary).filter(([key]) => key !== "bootstrap")) : null,
+              validation: validationSummary ? Object.fromEntries(Object.entries(validationSummary).filter(([key2]) => key2 !== "bootstrap")) : null,
               checkpoint: readRecord3(result?.checkpoint),
               worker: null,
               ...readRecord3(payload.finalBranchConvergenceState) ?? readRecord3(result?.finalBranchConvergenceState) ? { finalBranchConvergenceState: readRecord3(payload.finalBranchConvergenceState) ?? readRecord3(result?.finalBranchConvergenceState) } : {},
@@ -37506,7 +37597,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       };
     }
     function renderMeshCoordinatorTemplate(template, values) {
-      return template.replace(/\{\{\s*(meshId|workspace|serverName|adhdevMcpCommand|adhdevMcpArgs)\s*\}\}/g, (_, key) => values[key] || "");
+      return template.replace(/\{\{\s*(meshId|workspace|serverName|adhdevMcpCommand|adhdevMcpArgs)\s*\}\}/g, (_, key2) => values[key2] || "");
     }
     function replaceLegacyCliCommandMcpArgs(command, args) {
       return command.replace(
@@ -37515,9 +37606,9 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
       );
     }
     function resolveHermesCoordinatorHome(meshId, workspace) {
-      const key = `${meshId || "mesh"}
+      const key2 = `${meshId || "mesh"}
 ${(0, import_node_path.resolve)(workspace || os42.tmpdir())}`;
-      const hash2 = shortHash(key);
+      const hash2 = shortHash(key2);
       return (0, import_node_path.join)(os42.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash2}`);
     }
     function resolveMcpConfigPath(configPath, workspace) {
@@ -37993,9 +38084,9 @@ ${rendered}`, "utf-8");
       const seen = /* @__PURE__ */ new Set();
       const suggestions = [];
       for (const entry of [...collectProjectContextSuggestions(mesh), ...collectPackageScriptSuggestions(workspace)]) {
-        const key = `${entry.command} ${(entry.args || []).join(" ")}`.trim();
-        if (seen.has(key)) continue;
-        seen.add(key);
+        const key2 = `${entry.command} ${(entry.args || []).join(" ")}`.trim();
+        if (seen.has(key2)) continue;
+        seen.add(key2);
         suggestions.push(entry);
       }
       return {
@@ -38491,6 +38582,218 @@ ${rendered}`, "utf-8");
         OUTPUT_SUMMARY_CHARS = 2e3;
       }
     });
+    var mesh_json_config_exports = {};
+    __export2(mesh_json_config_exports, {
+      MESH_JSON_CONFIG_LOCATIONS: () => MESH_JSON_CONFIG_LOCATIONS,
+      MESH_JSON_CONFIG_SCHEMA: () => MESH_JSON_CONFIG_SCHEMA,
+      applyRepoMeshConfig: () => applyRepoMeshConfig,
+      buildMeshJsonConfigScaffold: () => buildMeshJsonConfigScaffold,
+      loadRepoMeshJsonConfig: () => loadRepoMeshJsonConfig,
+      mergeEffectiveCoordinatorConfig: () => mergeEffectiveCoordinatorConfig,
+      mergeEffectiveOperatingNotes: () => mergeEffectiveOperatingNotes,
+      normalizeRepoMeshDeclarativeConfig: () => normalizeRepoMeshDeclarativeConfig,
+      serializeMeshJsonConfigScaffold: () => serializeMeshJsonConfigScaffold
+    });
+    function isRecord3(value) {
+      return !!value && typeof value === "object" && !Array.isArray(value);
+    }
+    function parseConfigText4(path43, text) {
+      if (/\.json$/i.test(path43)) return JSON.parse(text);
+      return yaml4.load(text);
+    }
+    function normalizeOperatingNote(value) {
+      if (!isRecord3(value)) return null;
+      const text = typeof value.text === "string" ? value.text.trim() : "";
+      if (!text) return null;
+      const category = value.category === "provider_quirk" || value.category === "pattern_to_avoid" || value.category === "recovery_lesson" ? value.category : void 0;
+      return {
+        text,
+        ...category ? { category } : {},
+        ...typeof value.createdAt === "string" ? { createdAt: value.createdAt } : {},
+        ...typeof value.sourceCoordinator === "string" ? { sourceCoordinator: value.sourceCoordinator } : {}
+      };
+    }
+    function normalizeRepoMeshDeclarativeConfig(parsed) {
+      const errors = [];
+      if (!isRecord3(parsed)) return { valid: false, errors: ["config must be an object"] };
+      if (parsed.version !== 1) {
+        return { valid: false, errors: [`version must be 1 (got ${JSON.stringify(parsed.version)})`] };
+      }
+      const config2 = { version: 1 };
+      if (parsed.coordinator !== void 0) {
+        if (isRecord3(parsed.coordinator)) {
+          const coord = {};
+          const c = parsed.coordinator;
+          if (typeof c.systemPromptOverride === "string") coord.systemPromptOverride = c.systemPromptOverride;
+          if (typeof c.systemPromptAppend === "string") coord.systemPromptAppend = c.systemPromptAppend;
+          if (Number.isFinite(Number(c.maxPromptChars))) coord.maxPromptChars = Number(c.maxPromptChars);
+          config2.coordinator = coord;
+        } else {
+          errors.push("coordinator must be an object when provided");
+        }
+      }
+      if (parsed.operatingNotes !== void 0) {
+        if (Array.isArray(parsed.operatingNotes)) {
+          const notes = parsed.operatingNotes.map(normalizeOperatingNote).filter((n) => n !== null);
+          if (notes.length) config2.operatingNotes = notes;
+        } else {
+          errors.push("operatingNotes must be an array when provided");
+        }
+      }
+      if (parsed.limits !== void 0) {
+        if (isRecord3(parsed.limits)) {
+          const limits = {};
+          if (Number.isFinite(Number(parsed.limits.maxNoteChars))) limits.maxNoteChars = Number(parsed.limits.maxNoteChars);
+          if (Number.isFinite(Number(parsed.limits.maxNotes))) limits.maxNotes = Number(parsed.limits.maxNotes);
+          if (Object.keys(limits).length) config2.limits = limits;
+        } else {
+          errors.push("limits must be an object when provided");
+        }
+      }
+      return { valid: true, config: config2, errors };
+    }
+    function loadRepoMeshJsonConfig(workspace) {
+      const bases = [];
+      const ws = typeof workspace === "string" ? workspace.trim() : "";
+      if (ws) bases.push(ws);
+      let cwd = "";
+      try {
+        cwd = process.cwd();
+      } catch {
+      }
+      if (cwd && cwd !== ws) bases.push(cwd);
+      for (const base of bases) {
+        for (const relative5 of MESH_JSON_CONFIG_LOCATIONS) {
+          const configPath = (0, import_path9.join)(base, relative5);
+          if (!(0, import_fs10.existsSync)(configPath)) continue;
+          try {
+            const parsed = parseConfigText4(configPath, (0, import_fs10.readFileSync)(configPath, "utf-8"));
+            const result = normalizeRepoMeshDeclarativeConfig(parsed);
+            if (!result.valid || !result.config) {
+              return { source: relative5, sourceType: "invalid", path: configPath, error: result.errors.join("; ") };
+            }
+            return { config: result.config, source: relative5, sourceType: "repo_file", path: configPath };
+          } catch (error48) {
+            return { source: relative5, sourceType: "invalid", path: configPath, error: error48?.message || String(error48) };
+          }
+        }
+      }
+      return {
+        source: "unavailable",
+        sourceType: "unavailable",
+        error: `No repo mesh config found. Checked: ${MESH_JSON_CONFIG_LOCATIONS.join(", ")}`
+      };
+    }
+    function mergeEffectiveCoordinatorConfig(repoCoord, localCoord) {
+      const out = { ...localCoord || {} };
+      const localOverride = localCoord?.systemPromptOverride?.trim();
+      const repoOverride = repoCoord?.systemPromptOverride?.trim();
+      if (localOverride) {
+        out.systemPromptOverride = localCoord.systemPromptOverride;
+      } else if (repoOverride) {
+        out.systemPromptOverride = repoCoord.systemPromptOverride;
+      } else {
+        delete out.systemPromptOverride;
+      }
+      const repoAppend = repoCoord?.systemPromptAppend?.trim() ? repoCoord.systemPromptAppend.trim() : "";
+      const localAppendRaw = localCoord?.systemPromptAppend ?? localCoord?.systemPromptSuffix;
+      const localAppend = localAppendRaw?.trim() ? localAppendRaw.trim() : "";
+      const stacked = [repoAppend, localAppend].filter(Boolean).join("\n\n");
+      if (stacked) {
+        out.systemPromptAppend = stacked;
+        delete out.systemPromptSuffix;
+      }
+      return out;
+    }
+    function mergeEffectiveOperatingNotes(repoNotes, ledgerNotes) {
+      const usable = (notes) => Array.isArray(notes) ? notes.filter((n) => n && typeof n.text === "string" && n.text.trim()) : [];
+      const repo = usable(repoNotes);
+      const ledger = usable(ledgerNotes);
+      const ledgerTexts = new Set(ledger.map((n) => n.text.trim()));
+      const repoKept = repo.filter((n) => !ledgerTexts.has(n.text.trim()));
+      const merged = [...repoKept, ...ledger];
+      return merged.length ? merged : void 0;
+    }
+    function applyRepoMeshConfig(mesh, repoConfig) {
+      if (!repoConfig) return mesh;
+      return {
+        ...mesh,
+        coordinator: mergeEffectiveCoordinatorConfig(repoConfig.coordinator, mesh.coordinator)
+      };
+    }
+    function buildMeshJsonConfigScaffold(mesh) {
+      const scaffold = { version: 1 };
+      const coord = {};
+      const override = mesh.coordinator?.systemPromptOverride;
+      if (typeof override === "string" && override.trim()) coord.systemPromptOverride = override;
+      const append = mesh.coordinator?.systemPromptAppend ?? mesh.coordinator?.systemPromptSuffix;
+      if (typeof append === "string" && append.trim()) coord.systemPromptAppend = append;
+      if (Object.keys(coord).length) scaffold.coordinator = coord;
+      return scaffold;
+    }
+    function serializeMeshJsonConfigScaffold(config2) {
+      return JSON.stringify(config2, null, 2);
+    }
+    var import_fs10;
+    var import_path9;
+    var yaml4;
+    var MESH_JSON_CONFIG_LOCATIONS;
+    var MESH_JSON_CONFIG_SCHEMA;
+    var init_mesh_json_config = __esm2({
+      "src/config/mesh-json-config.ts"() {
+        "use strict";
+        import_fs10 = require("fs");
+        import_path9 = require("path");
+        yaml4 = __toESM2(require_js_yaml());
+        MESH_JSON_CONFIG_LOCATIONS = [
+          ".adhdev/mesh.json",
+          ".adhdev/mesh.yaml",
+          ".adhdev/mesh.yml"
+        ];
+        MESH_JSON_CONFIG_SCHEMA = {
+          $schema: "https://json-schema.org/draft/2020-12/schema",
+          title: "ADHDev Repo Mesh Declarative Config",
+          type: "object",
+          additionalProperties: false,
+          required: ["version"],
+          properties: {
+            version: { const: 1 },
+            coordinator: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                systemPromptOverride: { type: "string" },
+                systemPromptAppend: { type: "string" },
+                maxPromptChars: { type: "number", minimum: 1 }
+              }
+            },
+            operatingNotes: {
+              type: "array",
+              maxItems: 200,
+              items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["text"],
+                properties: {
+                  text: { type: "string", minLength: 1 },
+                  category: { enum: ["provider_quirk", "pattern_to_avoid", "recovery_lesson"] },
+                  createdAt: { type: "string" },
+                  sourceCoordinator: { type: "string" }
+                }
+              }
+            },
+            limits: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                maxNoteChars: { type: "number", minimum: 1 },
+                maxNotes: { type: "number", minimum: 1 }
+              }
+            }
+          }
+        };
+      }
+    });
     async function fastForwardMeshNode(args) {
       const workspace = typeof args.workspace === "string" ? args.workspace.trim() : "";
       const nodeId = normalizeOptionalString(args.nodeId);
@@ -39953,9 +40256,9 @@ Next step: ${nextStep}`;
       const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
       if (coordinatorDaemonId) {
         const safeDaemon = coordinatorDaemonId.replace(/[^a-zA-Z0-9_-]/g, "_");
-        return (0, import_path9.join)(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
+        return (0, import_path10.join)(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
       }
-      return (0, import_path9.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
+      return (0, import_path10.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
     }
     function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
       if (!meshId) return [];
@@ -39964,9 +40267,9 @@ Next step: ${nextStep}`;
       const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
       const events = [];
       for (const path43 of paths) {
-        if (!(0, import_fs10.existsSync)(path43)) continue;
+        if (!(0, import_fs11.existsSync)(path43)) continue;
         try {
-          const raw = (0, import_fs10.readFileSync)(path43, "utf-8");
+          const raw = (0, import_fs11.readFileSync)(path43, "utf-8");
           const parsed = raw.split("\n").filter(Boolean).flatMap((line) => {
             try {
               return [JSON.parse(line)];
@@ -40041,9 +40344,9 @@ Next step: ${nextStep}`;
     }
     function trimPendingEventsIfNeeded(path43) {
       try {
-        if (!(0, import_fs10.existsSync)(path43)) return;
-        if ((0, import_fs10.statSync)(path43).size <= MAX_PENDING_EVENTS_BYTES) return;
-        const lines = (0, import_fs10.readFileSync)(path43, "utf-8").split("\n").filter(Boolean);
+        if (!(0, import_fs11.existsSync)(path43)) return;
+        if ((0, import_fs11.statSync)(path43).size <= MAX_PENDING_EVENTS_BYTES) return;
+        const lines = (0, import_fs11.readFileSync)(path43, "utf-8").split("\n").filter(Boolean);
         if (lines.length <= MAX_PENDING_EVENTS_KEEP) return;
         const dropped = lines.slice(0, lines.length - MAX_PENDING_EVENTS_KEEP);
         for (const line of dropped) {
@@ -40076,7 +40379,7 @@ Next step: ${nextStep}`;
             LOG2.warn("MeshEvents", `Failed to ledger-record trim-dropped ${event.event} for mesh ${event.meshId}: ${e?.message || e}`);
           }
         }
-        (0, import_fs10.writeFileSync)(path43, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
+        (0, import_fs11.writeFileSync)(path43, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
       } catch {
       }
     }
@@ -40108,7 +40411,7 @@ Next step: ${nextStep}`;
         try {
           const path43 = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
           trimPendingEventsIfNeeded(path43);
-          (0, import_fs10.appendFileSync)(path43, JSON.stringify(event) + "\n", "utf-8");
+          (0, import_fs11.appendFileSync)(path43, JSON.stringify(event) + "\n", "utf-8");
         } catch (e) {
           if (!sqliteOk) throw e;
           LOG2.warn("MeshEvents", `JSONL append failed for mesh ${event.meshId}; SQLite holds the event: ${e?.message || e}`);
@@ -40122,20 +40425,20 @@ Next step: ${nextStep}`;
     function atomicDrainFile(path43) {
       const tmpPath = `${path43}.draining`;
       try {
-        (0, import_fs10.renameSync)(path43, tmpPath);
+        (0, import_fs11.renameSync)(path43, tmpPath);
       } catch {
         return null;
       }
       try {
-        const content = (0, import_fs10.readFileSync)(tmpPath, "utf-8");
+        const content = (0, import_fs11.readFileSync)(tmpPath, "utf-8");
         try {
-          (0, import_fs10.unlinkSync)(tmpPath);
+          (0, import_fs11.unlinkSync)(tmpPath);
         } catch {
         }
         return content;
       } catch {
         try {
-          (0, import_fs10.unlinkSync)(tmpPath);
+          (0, import_fs11.unlinkSync)(tmpPath);
         } catch {
         }
         return null;
@@ -40144,16 +40447,16 @@ Next step: ${nextStep}`;
     function selectiveDrainFile(path43, predicate) {
       const tmpPath = `${path43}.draining`;
       try {
-        (0, import_fs10.renameSync)(path43, tmpPath);
+        (0, import_fs11.renameSync)(path43, tmpPath);
       } catch {
         return [];
       }
       let content;
       try {
-        content = (0, import_fs10.readFileSync)(tmpPath, "utf-8");
+        content = (0, import_fs11.readFileSync)(tmpPath, "utf-8");
       } catch {
         try {
-          (0, import_fs10.unlinkSync)(tmpPath);
+          (0, import_fs11.unlinkSync)(tmpPath);
         } catch {
         }
         return [];
@@ -40176,12 +40479,12 @@ Next step: ${nextStep}`;
       }
       try {
         if (keptLines.length > 0) {
-          (0, import_fs10.writeFileSync)(path43, keptLines.join("\n") + "\n", "utf-8");
+          (0, import_fs11.writeFileSync)(path43, keptLines.join("\n") + "\n", "utf-8");
         }
-        (0, import_fs10.unlinkSync)(tmpPath);
+        (0, import_fs11.unlinkSync)(tmpPath);
       } catch {
         try {
-          if ((0, import_fs10.existsSync)(tmpPath) && !(0, import_fs10.existsSync)(path43)) (0, import_fs10.renameSync)(tmpPath, path43);
+          if ((0, import_fs11.existsSync)(tmpPath) && !(0, import_fs11.existsSync)(path43)) (0, import_fs11.renameSync)(tmpPath, path43);
         } catch {
         }
         return [];
@@ -40276,14 +40579,14 @@ Next step: ${nextStep}`;
       }
       const paths = coordinatorDaemonId ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
       for (const path43 of paths) {
-        if ((0, import_fs10.existsSync)(path43)) try {
-          (0, import_fs10.unlinkSync)(path43);
+        if ((0, import_fs11.existsSync)(path43)) try {
+          (0, import_fs11.unlinkSync)(path43);
         } catch {
         }
       }
     }
-    var import_fs10;
-    var import_path9;
+    var import_fs11;
+    var import_path10;
     var import_crypto8;
     var REFINE_TERMINAL_EVENTS;
     var TERMINAL_COMPLETION_EVENTS;
@@ -40292,8 +40595,8 @@ Next step: ${nextStep}`;
     var init_mesh_events_pending = __esm2({
       "src/mesh/mesh-events-pending.ts"() {
         "use strict";
-        import_fs10 = require("fs");
-        import_path9 = require("path");
+        import_fs11 = require("fs");
+        import_path10 = require("path");
         import_crypto8 = require("crypto");
         init_logger();
         init_mesh_ledger();
@@ -41070,7 +41373,7 @@ Next step: ${nextStep}`;
       if (isExplicitCommandPath(trimmed)) {
         const expanded = expandHome(trimmed);
         const candidate = path12.isAbsolute(expanded) ? expanded : path12.resolve(expanded);
-        return (0, import_fs11.existsSync)(candidate) ? candidate : null;
+        return (0, import_fs12.existsSync)(candidate) ? candidate : null;
       }
       return null;
     }
@@ -41080,7 +41383,7 @@ Next step: ${nextStep}`;
       const whichResult = await execAsync(`${whichCmd} ${shellQuote(command)}`);
       if (whichResult) return whichResult.split("\n")[0];
       const resolved = findBinary(command);
-      if (path12.isAbsolute(resolved) && (0, import_fs11.existsSync)(resolved)) return resolved;
+      if (path12.isAbsolute(resolved) && (0, import_fs12.existsSync)(resolved)) return resolved;
       return null;
     }
     function execAsync(cmd, timeoutMs = 5e3) {
@@ -41178,14 +41481,14 @@ Next step: ${nextStep}`;
     var import_child_process2;
     var os62;
     var path12;
-    var import_fs11;
+    var import_fs12;
     var init_cli_detector = __esm2({
       "src/detection/cli-detector.ts"() {
         "use strict";
         import_child_process2 = require("child_process");
         os62 = __toESM2(require("os"));
         path12 = __toESM2(require("path"));
-        import_fs11 = require("fs");
+        import_fs12 = require("fs");
         init_provider_cli_shared();
       }
     });
@@ -41301,348 +41604,9 @@ Next step: ${nextStep}`;
         "use strict";
       }
     });
-    var mesh_json_config_exports = {};
-    __export2(mesh_json_config_exports, {
-      MESH_JSON_CONFIG_LOCATIONS: () => MESH_JSON_CONFIG_LOCATIONS,
-      MESH_JSON_CONFIG_SCHEMA: () => MESH_JSON_CONFIG_SCHEMA,
-      __resetMeshJsonConfigCacheForTests: () => __resetMeshJsonConfigCacheForTests,
-      applyRepoMeshConfig: () => applyRepoMeshConfig,
-      buildMeshJsonConfigScaffold: () => buildMeshJsonConfigScaffold,
-      diffPolicyFromDefault: () => diffPolicyFromDefault,
-      loadMeshJsonConfig: () => loadMeshJsonConfig,
-      loadRepoMeshJsonConfig: () => loadRepoMeshJsonConfig,
-      mergeEffectiveCoordinatorConfig: () => mergeEffectiveCoordinatorConfig,
-      mergeEffectiveMeshPolicy: () => mergeEffectiveMeshPolicy,
-      mergeEffectiveOperatingNotes: () => mergeEffectiveOperatingNotes,
-      normalizeRepoMeshDeclarativeConfig: () => normalizeRepoMeshDeclarativeConfig,
-      serializeMeshJsonConfigScaffold: () => serializeMeshJsonConfigScaffold,
-      validateMeshJsonConfig: () => validateMeshJsonConfig
-    });
-    function isRecord3(value) {
-      return !!value && typeof value === "object" && !Array.isArray(value);
-    }
-    function parseConfigText4(path43, text) {
-      if (/\.json$/i.test(path43)) return JSON.parse(text);
-      return yaml4.load(text);
-    }
-    function normalizeOperatingNote(value) {
-      if (!isRecord3(value)) return null;
-      const text = typeof value.text === "string" ? value.text.trim() : "";
-      if (!text) return null;
-      const category = value.category === "provider_quirk" || value.category === "pattern_to_avoid" || value.category === "recovery_lesson" ? value.category : void 0;
-      return {
-        text,
-        ...category ? { category } : {},
-        ...typeof value.createdAt === "string" ? { createdAt: value.createdAt } : {},
-        ...typeof value.sourceCoordinator === "string" ? { sourceCoordinator: value.sourceCoordinator } : {}
-      };
-    }
-    function normalizeRepoMeshDeclarativeConfig(parsed) {
-      const errors = [];
-      if (!isRecord3(parsed)) return { valid: false, errors: ["config must be an object"] };
-      if (parsed.version !== 1) {
-        return { valid: false, errors: [`version must be 1 (got ${JSON.stringify(parsed.version)})`] };
-      }
-      const config2 = { version: 1 };
-      if (parsed.policy !== void 0) {
-        if (isRecord3(parsed.policy)) {
-          config2.policy = parsed.policy;
-        } else {
-          errors.push("policy must be an object when provided");
-        }
-      }
-      if (parsed.coordinator !== void 0) {
-        if (isRecord3(parsed.coordinator)) {
-          const coord = {};
-          const c = parsed.coordinator;
-          if (typeof c.systemPromptOverride === "string") coord.systemPromptOverride = c.systemPromptOverride;
-          if (typeof c.systemPromptAppend === "string") coord.systemPromptAppend = c.systemPromptAppend;
-          if (Number.isFinite(Number(c.maxPromptChars))) coord.maxPromptChars = Number(c.maxPromptChars);
-          config2.coordinator = coord;
-        } else {
-          errors.push("coordinator must be an object when provided");
-        }
-      }
-      if (parsed.operatingNotes !== void 0) {
-        if (Array.isArray(parsed.operatingNotes)) {
-          const notes = parsed.operatingNotes.map(normalizeOperatingNote).filter((n) => n !== null);
-          if (notes.length) config2.operatingNotes = notes;
-        } else {
-          errors.push("operatingNotes must be an array when provided");
-        }
-      }
-      if (parsed.limits !== void 0) {
-        if (isRecord3(parsed.limits)) {
-          const limits = {};
-          if (Number.isFinite(Number(parsed.limits.maxNoteChars))) limits.maxNoteChars = Number(parsed.limits.maxNoteChars);
-          if (Number.isFinite(Number(parsed.limits.maxNotes))) limits.maxNotes = Number(parsed.limits.maxNotes);
-          if (Object.keys(limits).length) config2.limits = limits;
-        } else {
-          errors.push("limits must be an object when provided");
-        }
-      }
-      return { valid: true, config: config2, errors };
-    }
-    function loadRepoMeshJsonConfig(workspace) {
-      const bases = [];
-      const ws = typeof workspace === "string" ? workspace.trim() : "";
-      if (ws) bases.push(ws);
-      let cwd = "";
-      try {
-        cwd = process.cwd();
-      } catch {
-      }
-      if (cwd && cwd !== ws) bases.push(cwd);
-      for (const base of bases) {
-        for (const relative5 of MESH_JSON_CONFIG_LOCATIONS) {
-          const configPath = (0, import_path10.join)(base, relative5);
-          if (!(0, import_fs12.existsSync)(configPath)) continue;
-          try {
-            const parsed = parseConfigText4(configPath, (0, import_fs12.readFileSync)(configPath, "utf-8"));
-            const result = normalizeRepoMeshDeclarativeConfig(parsed);
-            if (!result.valid || !result.config) {
-              return { source: relative5, sourceType: "invalid", path: configPath, error: result.errors.join("; ") };
-            }
-            return { config: result.config, source: relative5, sourceType: "repo_file", path: configPath };
-          } catch (error48) {
-            return { source: relative5, sourceType: "invalid", path: configPath, error: error48?.message || String(error48) };
-          }
-        }
-      }
-      return {
-        source: "unavailable",
-        sourceType: "unavailable",
-        error: `No repo mesh config found. Checked: ${MESH_JSON_CONFIG_LOCATIONS.join(", ")}`
-      };
-    }
-    function deepEqual(a, b) {
-      if (a === b) return true;
-      try {
-        return JSON.stringify(a) === JSON.stringify(b);
-      } catch {
-        return false;
-      }
+    function localCoordinatorDaemonId() {
+      return canonicalDaemonId(readNonEmptyString2(loadConfig2().machineId));
     }
-    function diffPolicyFromDefault(local) {
-      if (!local || typeof local !== "object") return {};
-      const out = {};
-      const def = mergeAndNormalizePolicy(void 0, void 0);
-      for (const [key, value] of Object.entries(local)) {
-        if (value === void 0) continue;
-        if (!deepEqual(value, def[key])) out[key] = value;
-      }
-      return out;
-    }
-    function mergeEffectiveMeshPolicy(repoPolicy, localPolicy) {
-      const repoMerged = mergeAndNormalizePolicy(void 0, repoPolicy);
-      const localOverrides = diffPolicyFromDefault(localPolicy);
-      return mergeAndNormalizePolicy(repoMerged, localOverrides);
-    }
-    function mergeEffectiveCoordinatorConfig(repoCoord, localCoord) {
-      const out = { ...localCoord || {} };
-      const localOverride = localCoord?.systemPromptOverride?.trim();
-      const repoOverride = repoCoord?.systemPromptOverride?.trim();
-      if (localOverride) {
-        out.systemPromptOverride = localCoord.systemPromptOverride;
-      } else if (repoOverride) {
-        out.systemPromptOverride = repoCoord.systemPromptOverride;
-      } else {
-        delete out.systemPromptOverride;
-      }
-      const repoAppend = repoCoord?.systemPromptAppend?.trim() ? repoCoord.systemPromptAppend.trim() : "";
-      const localAppendRaw = localCoord?.systemPromptAppend ?? localCoord?.systemPromptSuffix;
-      const localAppend = localAppendRaw?.trim() ? localAppendRaw.trim() : "";
-      const stacked = [repoAppend, localAppend].filter(Boolean).join("\n\n");
-      if (stacked) {
-        out.systemPromptAppend = stacked;
-        delete out.systemPromptSuffix;
-      }
-      return out;
-    }
-    function mergeEffectiveOperatingNotes(repoNotes, ledgerNotes) {
-      const usable = (notes) => Array.isArray(notes) ? notes.filter((n) => n && typeof n.text === "string" && n.text.trim()) : [];
-      const repo = usable(repoNotes);
-      const ledger = usable(ledgerNotes);
-      const ledgerTexts = new Set(ledger.map((n) => n.text.trim()));
-      const repoKept = repo.filter((n) => !ledgerTexts.has(n.text.trim()));
-      const merged = [...repoKept, ...ledger];
-      return merged.length ? merged : void 0;
-    }
-    function applyRepoMeshConfig(mesh, repoConfig) {
-      if (!repoConfig) return mesh;
-      return {
-        ...mesh,
-        policy: mergeEffectiveMeshPolicy(repoConfig.policy, mesh.policy),
-        coordinator: mergeEffectiveCoordinatorConfig(repoConfig.coordinator, mesh.coordinator)
-      };
-    }
-    function buildMeshJsonConfigScaffold(mesh) {
-      const scaffold = {
-        version: 1,
-        policy: mergeAndNormalizePolicy(void 0, mesh.policy)
-      };
-      const coord = {};
-      const override = mesh.coordinator?.systemPromptOverride;
-      if (typeof override === "string" && override.trim()) coord.systemPromptOverride = override;
-      const append = mesh.coordinator?.systemPromptAppend ?? mesh.coordinator?.systemPromptSuffix;
-      if (typeof append === "string" && append.trim()) coord.systemPromptAppend = append;
-      if (Object.keys(coord).length) scaffold.coordinator = coord;
-      return scaffold;
-    }
-    function serializeMeshJsonConfigScaffold(config2) {
-      return JSON.stringify(config2, null, 2);
-    }
-    function validateMeshJsonConfig(raw, source = "inline") {
-      const errors = [];
-      if (!isRecord3(raw)) {
-        return { valid: false, errors: [`${source}: config must be an object`] };
-      }
-      const config2 = {};
-      const policy = raw.policy;
-      const schedulingRaw = isRecord3(policy) ? policy.scheduling : void 0;
-      if (schedulingRaw !== void 0) {
-        if (!isRecord3(schedulingRaw)) {
-          errors.push("policy.scheduling must be an object");
-        } else {
-          const scheduling = {};
-          if (schedulingRaw.distribution !== void 0) {
-            if (typeof schedulingRaw.distribution !== "string" || !["spread", "in_order"].includes(schedulingRaw.distribution.trim())) {
-              errors.push("policy.scheduling.distribution must be 'spread' or 'in_order'");
-            } else {
-              scheduling.distribution = normalizeMeshDistribution(schedulingRaw.distribution);
-            }
-          }
-          if (schedulingRaw.maxParallel !== void 0) {
-            const n = Number(schedulingRaw.maxParallel);
-            if (!Number.isFinite(n) || n < MESH_MAX_PARALLEL_TASKS_MIN || n > MESH_MAX_PARALLEL_TASKS_MAX) {
-              errors.push(`policy.scheduling.maxParallel must be a number in [${MESH_MAX_PARALLEL_TASKS_MIN}, ${MESH_MAX_PARALLEL_TASKS_MAX}]`);
-            } else {
-              scheduling.maxParallel = Math.floor(n);
-            }
-          }
-          if (schedulingRaw.readonlyMultiplier !== void 0) {
-            const n = Number(schedulingRaw.readonlyMultiplier);
-            if (!Number.isFinite(n) || n < 1) {
-              errors.push("policy.scheduling.readonlyMultiplier must be a number >= 1");
-            } else {
-              scheduling.readonlyMultiplier = Math.floor(n);
-            }
-          }
-          for (const key of Object.keys(schedulingRaw)) {
-            if (!["distribution", "maxParallel", "readonlyMultiplier"].includes(key)) {
-              errors.push(`policy.scheduling.${key} is not a recognized field`);
-            }
-          }
-          if (Object.keys(scheduling).length) config2.scheduling = scheduling;
-        }
-      }
-      return { valid: errors.length === 0, errors, config: errors.length === 0 ? config2 : void 0 };
-    }
-    function loadMeshJsonConfig(repoRoot) {
-      if (!repoRoot) {
-        return { source: "unavailable", sourceType: "unavailable", error: "no repo root", sourceKey: "unavailable" };
-      }
-      for (const relative5 of MESH_JSON_CONFIG_LOCATIONS) {
-        const configPath = (0, import_path10.join)(repoRoot, relative5);
-        if (!(0, import_fs12.existsSync)(configPath)) continue;
-        let mtimeMs = 0;
-        try {
-          mtimeMs = (0, import_fs12.statSync)(configPath).mtimeMs;
-        } catch {
-          mtimeMs = 0;
-        }
-        const cacheKey = configPath;
-        const sourceKey = `file:${configPath}:${mtimeMs}`;
-        const cached3 = cache.get(cacheKey);
-        if (cached3 && cached3.sourceKey === sourceKey) return cached3.result;
-        let result;
-        try {
-          const text = (0, import_fs12.readFileSync)(configPath, "utf-8");
-          const parsed = parseConfigText4(configPath, text);
-          const validation = validateMeshJsonConfig(parsed, relative5);
-          result = validation.valid ? { config: validation.config, source: relative5, sourceType: "repo_file", path: configPath, sourceKey } : { source: relative5, sourceType: "invalid", path: configPath, error: validation.errors.join("; "), sourceKey: `invalid:${configPath}:${mtimeMs}` };
-        } catch (error48) {
-          result = { source: relative5, sourceType: "invalid", path: configPath, error: error48?.message || String(error48), sourceKey: `error:${configPath}` };
-        }
-        cache.set(cacheKey, { sourceKey: result.sourceKey, result });
-        return result;
-      }
-      return {
-        source: "unavailable",
-        sourceType: "unavailable",
-        error: `No .adhdev/mesh config found. Checked: ${MESH_JSON_CONFIG_LOCATIONS.join(", ")}`,
-        sourceKey: "unavailable"
-      };
-    }
-    function __resetMeshJsonConfigCacheForTests() {
-      cache.clear();
-    }
-    var import_fs12;
-    var import_path10;
-    var yaml4;
-    var MESH_JSON_CONFIG_LOCATIONS;
-    var MESH_JSON_CONFIG_SCHEMA;
-    var cache;
-    var init_mesh_json_config = __esm2({
-      "src/config/mesh-json-config.ts"() {
-        "use strict";
-        import_fs12 = require("fs");
-        import_path10 = require("path");
-        yaml4 = __toESM2(require_js_yaml());
-        init_repo_mesh_types();
-        MESH_JSON_CONFIG_LOCATIONS = [
-          ".adhdev/mesh.json",
-          ".adhdev/mesh.yaml",
-          ".adhdev/mesh.yml"
-        ];
-        MESH_JSON_CONFIG_SCHEMA = {
-          $schema: "https://json-schema.org/draft/2020-12/schema",
-          title: "ADHDev Repo Mesh Declarative Config",
-          type: "object",
-          additionalProperties: false,
-          required: ["version"],
-          properties: {
-            version: { const: 1 },
-            // policy is validated/normalized through mergeAndNormalizePolicy at merge
-            // time; the schema here only asserts it is an object.
-            policy: { type: "object" },
-            coordinator: {
-              type: "object",
-              additionalProperties: false,
-              properties: {
-                systemPromptOverride: { type: "string" },
-                systemPromptAppend: { type: "string" },
-                maxPromptChars: { type: "number", minimum: 1 }
-              }
-            },
-            operatingNotes: {
-              type: "array",
-              maxItems: 200,
-              items: {
-                type: "object",
-                additionalProperties: false,
-                required: ["text"],
-                properties: {
-                  text: { type: "string", minLength: 1 },
-                  category: { enum: ["provider_quirk", "pattern_to_avoid", "recovery_lesson"] },
-                  createdAt: { type: "string" },
-                  sourceCoordinator: { type: "string" }
-                }
-              }
-            },
-            limits: {
-              type: "object",
-              additionalProperties: false,
-              properties: {
-                maxNoteChars: { type: "number", minimum: 1 },
-                maxNotes: { type: "number", minimum: 1 }
-              }
-            }
-          }
-        };
-        cache = /* @__PURE__ */ new Map();
-      }
-    });
     function __resetIdleAutoFastForwardForTests() {
       idleAutoFastForwardLastAttempt.clear();
     }
@@ -41728,6 +41692,7 @@ Next step: ${nextStep}`;
         if (timer) clearTimeout(timer);
         LOG2.error("MeshQueue", `Failed to dispatch task via ${ctx.transport} to node ${ctx.nodeId}: ${e?.message}`);
         updateSessionDeliveryStatus(delivery.id, "failed", { lastError: e?.message, incrementAttempt: true });
+        endTaskDispatchInFlight(ctx.meshId, ctx.task.id);
         updateTaskStatus(ctx.meshId, ctx.task.id, "pending");
         try {
           appendLedgerEntry(ctx.meshId, {
@@ -41801,10 +41766,11 @@ Next step: ${nextStep}`;
         return false;
       }
       LOG2.info("MeshQueue", `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
+      beginTaskDispatchInFlight(meshId, task.id);
       if (node?.daemonId && components.dispatchMeshCommand) {
         const isLocalNode = components.cliManager.adapters.has(sessionId);
         if (!isLocalNode) {
-          const localDaemonIdForDispatch = readNonEmptyString2(loadConfig2().machineId) || void 0;
+          const localDaemonIdForDispatch = localCoordinatorDaemonId();
           const sourceCoordinatorSessionId = readNonEmptyString2(task.sourceCoordinatorSessionId) || void 0;
           const dispatchMeshCommand = components.dispatchMeshCommand;
           const remoteDaemonId = node.daemonId;
@@ -41843,7 +41809,7 @@ Next step: ${nextStep}`;
       try {
         const inst = components.instanceManager.getInstance(sessionId);
         if (inst && typeof inst.updateSettings === "function") {
-          const localDaemonId = readNonEmptyString2(loadConfig2().machineId);
+          const localDaemonId = localCoordinatorDaemonId();
           const localSourceCoordinatorSessionId = readNonEmptyString2(task.sourceCoordinatorSessionId);
           inst.updateSettings({
             meshNodeFor: meshId,
@@ -41868,7 +41834,7 @@ Next step: ${nextStep}`;
             meshId,
             nodeId,
             taskId: task.id,
-            ...readNonEmptyString2(loadConfig2().machineId) ? { coordinatorDaemonId: readNonEmptyString2(loadConfig2().machineId) } : {},
+            ...localCoordinatorDaemonId() ? { coordinatorDaemonId: localCoordinatorDaemonId() } : {},
             ...readNonEmptyString2(task.sourceCoordinatorSessionId) ? { coordinatorSessionId: readNonEmptyString2(task.sourceCoordinatorSessionId) } : {}
           }
         }),
@@ -41880,7 +41846,7 @@ Next step: ${nextStep}`;
           task,
           transport: "local",
           ...readNonEmptyString2(task.sourceCoordinatorSessionId) ? { sourceCoordinatorSessionId: readNonEmptyString2(task.sourceCoordinatorSessionId) } : {},
-          ...readNonEmptyString2(loadConfig2().machineId) ? { sourceCoordinatorDaemonId: readNonEmptyString2(loadConfig2().machineId) } : {}
+          ...localCoordinatorDaemonId() ? { sourceCoordinatorDaemonId: localCoordinatorDaemonId() } : {}
         }
       );
       return true;
@@ -41962,8 +41928,8 @@ Next step: ${nextStep}`;
     }
     function sweepExpiredCooldowns() {
       const now = Date.now();
-      for (const [key, until] of autoLaunchCooldownUntil) {
-        if (now >= until) autoLaunchCooldownUntil.delete(key);
+      for (const [key2, until] of autoLaunchCooldownUntil) {
+        if (now >= until) autoLaunchCooldownUntil.delete(key2);
       }
     }
     function normalizeProviderPriority(policy) {
@@ -42009,7 +41975,7 @@ Next step: ${nextStep}`;
         const settings = state.settings || {};
         if (readNonEmptyString2(settings.meshNodeFor) !== meshId) return false;
         const instNodeId = readNonEmptyString2(settings.meshNodeId) || readNonEmptyString2(settings.nodeId);
-        if (instNodeId !== nodeId) return false;
+        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
         const sessionId = readNonEmptyString2(state.instanceId);
         if (currentSessionId && sessionId === currentSessionId && isIdleSessionState(state)) return false;
         return sessionStateLooksActive(state);
@@ -42041,7 +42007,7 @@ Next step: ${nextStep}`;
       const daemonId = readNonEmptyString2(node?.daemonId);
       if (!daemonId) return { mode: "skip", reason: "remote_auto_launch_unsupported" };
       if (!components.dispatchMeshCommand) return { mode: "skip", reason: "remote_auto_launch_unsupported" };
-      const coordinatorDaemonId = readNonEmptyString2(loadConfig2().machineId);
+      const coordinatorDaemonId = localCoordinatorDaemonId();
       if (!coordinatorDaemonId) return { mode: "skip", reason: "remote_auto_launch_no_coordinator_daemon_id" };
       return { mode: "remote", daemonId, coordinatorDaemonId };
     }
@@ -42052,31 +42018,12 @@ Next step: ${nextStep}`;
       return getQueue(meshId, { status: ["assigned"] }).filter(isTaskReadonly).length;
     }
     function nodeHasActiveAssignment(meshId, nodeId) {
-      return getQueue(meshId, { status: ["assigned"] }).some((task) => task.assignedNodeId === nodeId);
+      return getQueue(meshId, { status: ["assigned"] }).some((task) => daemonIdsEquivalent(task.assignedNodeId, nodeId));
     }
     function nodeActiveLoad(meshId, nodeId) {
       return MeshRuntimeStore.getInstance().nodeActiveAssignmentCount(meshId, nodeId);
     }
-    function resolveMeshRepoRootForScheduling(mesh) {
-      const nodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
-      const pickRoot = (n) => readNonEmptyString2(n?.repoRoot) || readNonEmptyString2(n?.workspace);
-      const base = nodes.find((n) => n?.isLocalWorktree !== true && pickRoot(n));
-      if (base) return pickRoot(base);
-      const anyNode = nodes.find((n) => pickRoot(n));
-      return anyNode ? pickRoot(anyNode) : "";
-    }
-    function resolveMeshSchedulingOverride(mesh) {
-      const repoRoot = resolveMeshRepoRootForScheduling(mesh);
-      if (!repoRoot) return void 0;
-      try {
-        return loadMeshJsonConfig(repoRoot).config?.scheduling;
-      } catch {
-        return void 0;
-      }
-    }
     function resolveSchedulingStrategy(mesh) {
-      const override = resolveMeshSchedulingOverride(mesh);
-      if (override?.distribution) return distributionToStrategy(override.distribution);
       return normalizeMeshSchedulingStrategy(mesh?.policy?.schedulingStrategy);
     }
     function orderEligibleNodes(meshId, strategy, nodes, opts) {
@@ -42101,7 +42048,7 @@ Next step: ${nextStep}`;
       });
     }
     function activeProviderAssignedCount(meshId, nodeId, providerType) {
-      return getQueue(meshId, { status: ["assigned"] }).filter((task) => task.assignedNodeId === nodeId && task.assignedProviderType === providerType).length;
+      return getQueue(meshId, { status: ["assigned"] }).filter((task) => daemonIdsEquivalent(task.assignedNodeId, nodeId) && task.assignedProviderType === providerType).length;
     }
     function sessionHasActiveAssignment(meshId, sessionId) {
       if (getQueue(meshId, { status: ["assigned"] }).some((task) => task.assignedSessionId === sessionId)) {
@@ -42120,7 +42067,7 @@ Next step: ${nextStep}`;
         const settings = state.settings || {};
         if (readNonEmptyString2(settings.meshNodeFor) !== meshId) return false;
         const instNodeId = readNonEmptyString2(settings.meshNodeId) || readNonEmptyString2(settings.nodeId);
-        if (instNodeId !== nodeId) return false;
+        if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
         const status = readNonEmptyString2(state.status).toLowerCase();
         return !isTerminalSessionStatus(status);
       }).length;
@@ -42219,11 +42166,8 @@ Next step: ${nextStep}`;
       const queue = getQueue(meshId);
       const pending = queue.filter((task) => task.status === "pending");
       if (!pending.length) return false;
-      const schedulingOverride = resolveMeshSchedulingOverride(mesh);
-      const maxParallelTasks = resolveMaxParallelTasks(
-        schedulingOverride?.maxParallel ?? mesh?.policy?.maxParallelTasks
-      );
-      const maxReadonlyParallelTasks = resolveMaxReadonlyParallelTasks(maxParallelTasks, schedulingOverride?.readonlyMultiplier);
+      const maxParallelTasks = resolveMaxParallelTasks(mesh?.policy?.maxParallelTasks);
+      const maxReadonlyParallelTasks = resolveMaxReadonlyParallelTasks(maxParallelTasks);
       for (const task of pending) {
         const isReadonly = isTaskReadonly(task);
         if (isReadonly) {
@@ -42652,12 +42596,12 @@ Next step: ${nextStep}`;
         init_mesh_event_trace();
         init_mesh_warmup_deadline();
         init_repo_mesh_types();
-        init_mesh_json_config();
         init_dist();
         init_mesh_events_stale();
         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;
@@ -42756,8 +42700,8 @@ Next step: ${nextStep}`;
       if (last !== void 0 && now - last < UNROUTABLE_DIAGNOSTIC_DEDUP_MS) return false;
       recentUnroutableDiagnostics.set(dedupKey, now);
       if (recentUnroutableDiagnostics.size > 256) {
-        for (const [key, ts2] of recentUnroutableDiagnostics) {
-          if (now - ts2 >= UNROUTABLE_DIAGNOSTIC_DEDUP_MS) recentUnroutableDiagnostics.delete(key);
+        for (const [key2, ts2] of recentUnroutableDiagnostics) {
+          if (now - ts2 >= UNROUTABLE_DIAGNOSTIC_DEDUP_MS) recentUnroutableDiagnostics.delete(key2);
         }
       }
       try {
@@ -43019,9 +42963,9 @@ Next step: ${nextStep}`;
         for (const line of stdout.split("\n")) {
           const m = line.match(/^\s*Pages\s+([^:]+):\s+([\d,]+)\s*\.?/);
           if (!m) continue;
-          const key = m[1].trim().toLowerCase().replace(/\s+/g, "_");
+          const key2 = m[1].trim().toLowerCase().replace(/\s+/g, "_");
           const n = parseInt(m[2].replace(/,/g, ""), 10);
-          if (!Number.isNaN(n)) counts[key] = n;
+          if (!Number.isNaN(n)) counts[key2] = n;
         }
         const free = counts["free"] ?? 0;
         const inactive = counts["inactive"] ?? 0;
@@ -43252,7 +43196,7 @@ Next step: ${nextStep}`;
       if (Array.isArray(value)) return value.map((item) => trimStructuredStrings(item, maxChars));
       if (!value || typeof value !== "object") return value;
       return Object.fromEntries(
-        Object.entries(value).map(([key, nested]) => [key, trimStructuredStrings(nested, maxChars)])
+        Object.entries(value).map(([key2, nested]) => [key2, trimStructuredStrings(nested, maxChars)])
       );
     }
     function estimateBytes(value) {
@@ -43841,9 +43785,9 @@ Next step: ${nextStep}`;
     function readStringField(value) {
       return typeof value === "string" ? value.trim().toLowerCase() : "";
     }
-    function readRecordField(message, meta3, key) {
+    function readRecordField(message, meta3, key2) {
       const record2 = message;
-      return record2[key] ?? meta3?.[key];
+      return record2[key2] ?? meta3?.[key2];
     }
     function readVisibilityField(message, meta3) {
       return readStringField(readRecordField(message, meta3, "visibility"));
@@ -43854,7 +43798,7 @@ Next step: ${nextStep}`;
     }
     function hasBooleanMarker(message, meta3, keys) {
       const record2 = message;
-      return keys.some((key) => record2[key] === true || meta3?.[key] === true);
+      return keys.some((key2) => record2[key2] === true || meta3?.[key2] === true);
     }
     function isActivityKind(kind) {
       return kind === "thought" || kind === "tool" || kind === "terminal";
@@ -44058,9 +44002,9 @@ Next step: ${nextStep}`;
       const values = {};
       const explicit = data.controlValues;
       if (explicit && typeof explicit === "object") {
-        for (const [key, value] of Object.entries(explicit)) {
+        for (const [key2, value] of Object.entries(explicit)) {
           if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-            values[key] = value;
+            values[key2] = value;
           }
         }
       }
@@ -44519,26 +44463,26 @@ ${cleanBody}`;
       if (!workspace) return void 0;
       return options.getGitSummaryForWorkspace?.(workspace) || void 0;
     }
-    function findCdpManager(cdpManagers, key) {
-      const exact = cdpManagers.get(key);
+    function findCdpManager(cdpManagers, key2) {
+      const exact = cdpManagers.get(key2);
       if (exact) return exact.isConnected ? exact : null;
-      const prefix = key + "_";
+      const prefix = key2 + "_";
       const matches = [...cdpManagers.entries()].filter(([k, m]) => m.isConnected && k.startsWith(prefix));
       if (matches.length === 1) return matches[0][1];
       return null;
     }
-    function hasCdpManager(cdpManagers, key) {
-      if (cdpManagers.has(key)) return true;
-      const prefix = key + "_";
+    function hasCdpManager(cdpManagers, key2) {
+      if (cdpManagers.has(key2)) return true;
+      const prefix = key2 + "_";
       for (const k of cdpManagers.keys()) {
         if (k.startsWith(prefix)) return true;
       }
       return false;
     }
-    function isCdpConnected(cdpManagers, key) {
-      const exact = cdpManagers.get(key);
+    function isCdpConnected(cdpManagers, key2) {
+      const exact = cdpManagers.get(key2);
       if (exact?.isConnected) return true;
-      const prefix = key + "_";
+      const prefix = key2 + "_";
       for (const [k, m] of cdpManagers.entries()) {
         if (m.isConnected && k.startsWith(prefix)) return true;
       }
@@ -44874,11 +44818,11 @@ ${cleanBody}`;
         String(snapshot.messageUpdatedAt)
       ].join("|");
     }
-    function shouldEmitRecentReadDebugLog(cache2, snapshot) {
+    function shouldEmitRecentReadDebugLog(cache, snapshot) {
       const nextSignature = buildRecentReadDebugSignature(snapshot);
-      const previousSignature = cache2.get(snapshot.sessionId);
+      const previousSignature = cache.get(snapshot.sessionId);
       if (previousSignature === nextSignature) return false;
-      cache2.set(snapshot.sessionId, nextSignature);
+      cache.set(snapshot.sessionId, nextSignature);
       return true;
     }
     function buildDetectedIdeInfos(detectedIdes, cdpManagers) {
@@ -46436,9 +46380,9 @@ ${cleanBody}`;
       for (const event of pending) {
         if (!shouldForceInjectMeshEvent(event.event)) continue;
         const fingerprint = buildPendingEventFingerprint(event);
-        const key = `${meshId}::${fingerprint || `${event.event}::${event.nodeId || ""}::${event.queuedAt}`}`;
-        if (heldEventLedgerRecorded.has(key)) continue;
-        heldEventLedgerRecorded.add(key);
+        const key2 = `${meshId}::${fingerprint || `${event.event}::${event.nodeId || ""}::${event.queuedAt}`}`;
+        if (heldEventLedgerRecorded.has(key2)) continue;
+        heldEventLedgerRecorded.add(key2);
         const finalSummary = readMeshCompletionSummary(event.metadataEvent);
         try {
           appendLedgerEntry(meshId, {
@@ -46459,7 +46403,7 @@ ${cleanBody}`;
           });
           LOG2.info("MeshReconcile", `Ledger-recorded held ${event.event} for mesh ${meshId} (reason ${reason}) \u2014 recoverable from ledger`);
         } catch (e) {
-          heldEventLedgerRecorded.delete(key);
+          heldEventLedgerRecorded.delete(key2);
           LOG2.warn("MeshReconcile", `Failed to ledger-record held ${event.event} for mesh ${meshId}: ${e?.message || e}`);
         }
       }
@@ -46924,9 +46868,9 @@ ${cleanBody}`;
       const activeTaskKeys = new Set(
         dispatches.map((d) => readNonEmptyString2(d.taskId)).filter(Boolean).map((taskId) => inFlightSynthKey(mesh.id, taskId))
       );
-      for (const key of inFlightAckedHoldState.keys()) {
-        if (key.startsWith(`${mesh.id}::`) && !activeTaskKeys.has(key)) {
-          inFlightAckedHoldState.delete(key);
+      for (const key2 of inFlightAckedHoldState.keys()) {
+        if (key2.startsWith(`${mesh.id}::`) && !activeTaskKeys.has(key2)) {
+          inFlightAckedHoldState.delete(key2);
         }
       }
       const dispatchMeshCommand = components.dispatchMeshCommand;
@@ -48514,8 +48458,8 @@ ${cleanBody}`;
             label += " " + next.trim();
             j += 1;
           }
-          const key = keyTemplate.replace(/\{index\}/g, String(idx));
-          buttons.push({ index: idx, label, key, current });
+          const key2 = keyTemplate.replace(/\{index\}/g, String(idx));
+          buttons.push({ index: idx, label, key: key2, current });
           i = j - 1;
         }
       } else {
@@ -48525,8 +48469,8 @@ ${cleanBody}`;
           const idx = Number(m[1]);
           const label = String(m[2] ?? "").trim();
           if (!Number.isFinite(idx) || idx <= 0 || !label) continue;
-          const key = keyTemplate.replace(/\{index\}/g, String(idx));
-          buttons.push({ index: idx, label, key, current: hasCursorMarker(m[0]) });
+          const key2 = keyTemplate.replace(/\{index\}/g, String(idx));
+          buttons.push({ index: idx, label, key: key2, current: hasCursorMarker(m[0]) });
         }
       }
       const block2 = lastContiguousNumberedBlock(buttons);
@@ -48604,12 +48548,12 @@ ${cleanBody}`;
         return { kind: "elapsed", result, detail: `elapsed ${age}ms / ${cond.elapsed_ms}ms`, remainingMs };
       }
       if (isStable(cond)) {
-        const key = regionKey(cond.cursor_above);
-        const lastChanged = clock.regionLastChangedAt.get(key) ?? clock.stateEnteredAt;
+        const key2 = regionKey(cond.cursor_above);
+        const lastChanged = clock.regionLastChangedAt.get(key2) ?? clock.stateEnteredAt;
         const stableFor = clock.now - lastChanged;
         const result = stableFor >= cond.stable_ms;
         const remainingMs = result ? 0 : cond.stable_ms - stableFor;
-        const where = key === WHOLE_SCREEN ? "screen" : `cursor_above=${cond.cursor_above}`;
+        const where = key2 === WHOLE_SCREEN ? "screen" : `cursor_above=${cond.cursor_above}`;
         return { kind: "stable", result, detail: `stable ${where} ${stableFor}ms / ${cond.stable_ms}ms`, remainingMs };
       }
       if (isRegex(cond) || isChanged(cond)) {
@@ -52544,16 +52488,16 @@ ${lastSnapshot}`;
     }
     function buildFsShim() {
       const shim = {};
-      for (const key of FS_READ_ONLY_MEMBERS) {
-        if (key === "promises") continue;
-        const real = nodeFs[key];
-        if (real !== void 0) shim[key] = real;
+      for (const key2 of FS_READ_ONLY_MEMBERS) {
+        if (key2 === "promises") continue;
+        const real = nodeFs[key2];
+        if (real !== void 0) shim[key2] = real;
       }
       const realPromises = nodeFs.promises || {};
       const promisesShim = {};
-      for (const key of FS_PROMISES_READ_ONLY_MEMBERS) {
-        const real = realPromises[key];
-        if (real !== void 0) promisesShim[key] = real;
+      for (const key2 of FS_PROMISES_READ_ONLY_MEMBERS) {
+        const real = realPromises[key2];
+        if (real !== void 0) promisesShim[key2] = real;
       }
       shim.promises = promisesShim;
       return shim;
@@ -52636,10 +52580,10 @@ ${lastSnapshot}`;
     function buildProcessShim() {
       const real = globalThis.process;
       const shim = /* @__PURE__ */ Object.create(null);
-      for (const key of Object.keys(real)) {
-        if (DANGEROUS_PROCESS_METHODS.has(String(key))) continue;
+      for (const key2 of Object.keys(real)) {
+        if (DANGEROUS_PROCESS_METHODS.has(String(key2))) continue;
         try {
-          shim[key] = real[key];
+          shim[key2] = real[key2];
         } catch {
         }
       }
@@ -52975,6 +52919,7 @@ ${lastSnapshot}`;
       buildToolChatMessage: () => buildToolChatMessage,
       buildUserChatMessage: () => buildUserChatMessage,
       cancelTask: () => cancelTask,
+      canonicalDaemonId: () => canonicalDaemonId,
       claimNextTask: () => claimNextTask,
       classifyChatMessageVisibility: () => classifyChatMessageVisibility,
       classifyHotChatSessionsForSubscriptionFlush: () => classifyHotChatSessionsForSubscriptionFlush2,
@@ -53103,6 +53048,7 @@ ${lastSnapshot}`;
       loadMeshCoordinatorRegistry: () => loadMeshCoordinatorRegistry,
       loadMeshRefineConfig: () => loadMeshRefineConfig,
       loadMeshWorktreeBootstrapConfig: () => loadMeshWorktreeBootstrapConfig,
+      loadRepoSettings: () => loadRepoSettings,
       loadState: () => loadState,
       logCommand: () => logCommand,
       machineCoreFromDaemonId: () => machineCoreFromDaemonId,
@@ -53826,10 +53772,10 @@ ${lastSnapshot}`;
         const compactSummary = createGitCompactSummary(status, diffSummary);
         const timestamp = this.now();
         const seq = ++this.seq;
-        const key = this.keyForWorkspace(normalized.workspace);
+        const key2 = this.keyForWorkspace(normalized.workspace);
         const update = {
           topic: "workspace.git",
-          key,
+          key: key2,
           workspace: normalized.workspace,
           status,
           diffSummary,
@@ -53837,7 +53783,7 @@ ${lastSnapshot}`;
           timestamp
         };
         const cacheEntry = {
-          key,
+          key: key2,
           workspace: normalized.workspace,
           status,
           diffSummary,
@@ -53979,11 +53925,11 @@ ${lastSnapshot}`;
       }
       return { path: args.path.trim() };
     }
-    function validateSnapshotId(args, key) {
-      if (typeof args?.[key] !== "string" || !args[key].trim()) {
-        return failure("invalid_args", `${key} must be a non-empty string`);
+    function validateSnapshotId(args, key2) {
+      if (typeof args?.[key2] !== "string" || !args[key2].trim()) {
+        return failure("invalid_args", `${key2} must be a non-empty string`);
       }
-      return args[key].trim();
+      return args[key2].trim();
     }
     function parseSnapshotReason(args) {
       if (args?.reason === void 0 || args?.reason === null || args?.reason === "") {
@@ -54455,6 +54401,25 @@ ${lastSnapshot}`;
     init_coordinator_registry();
     init_refine_config();
     init_worktree_bootstrap_config();
+    init_mesh_json_config();
+    init_refine_config();
+    init_worktree_bootstrap_config();
+    init_change_impact_config();
+    function loadRepoSettings(opts) {
+      const workspace = typeof opts.workspace === "string" ? opts.workspace : "";
+      const mesh = opts.mesh;
+      const repoRoot = typeof opts.repoRoot === "string" && opts.repoRoot ? opts.repoRoot : workspace;
+      const meshJson = loadRepoMeshJsonConfig(workspace);
+      return {
+        coordinator: meshJson.config?.coordinator,
+        operatingNotes: meshJson.config?.operatingNotes,
+        limits: meshJson.config?.limits,
+        meshJson,
+        refine: loadMeshRefineConfig(mesh, workspace),
+        worktreeBootstrap: loadMeshWorktreeBootstrapConfig(mesh, workspace),
+        changeImpact: loadChangeImpactConfig(repoRoot)
+      };
+    }
     init_mesh_ledger();
     init_mesh_fast_forward();
     function lastTimestamp(slice) {
@@ -56332,10 +56297,10 @@ ${lastSnapshot}`;
         return events;
       }
       /** Cooldown check — prevent sending the same notification too frequently */
-      shouldAlert(key, now) {
-        const last = this.lastAlertTime.get(key) || 0;
+      shouldAlert(key2, now) {
+        const last = this.lastAlertTime.get(key2) || 0;
         if (now - last > this.config.alertCooldownSec * 1e3) {
-          this.lastAlertTime.set(key, now);
+          this.lastAlertTime.set(key2, now);
           return true;
         }
         return false;
@@ -56379,16 +56344,16 @@ ${lastSnapshot}`;
     var savedHistoryRollupInFlight = /* @__PURE__ */ new Set();
     var BOUNDED_TAIL_CACHE_MAX_ENTRIES = 64;
     var boundedTailReadCache = /* @__PURE__ */ new Map();
-    function readBoundedTailCache(key, signature) {
-      const cached3 = boundedTailReadCache.get(key);
+    function readBoundedTailCache(key2, signature) {
+      const cached3 = boundedTailReadCache.get(key2);
       if (!cached3 || cached3.signature !== signature) return null;
-      boundedTailReadCache.delete(key);
-      boundedTailReadCache.set(key, cached3);
+      boundedTailReadCache.delete(key2);
+      boundedTailReadCache.set(key2, cached3);
       return cached3.result;
     }
-    function writeBoundedTailCache(key, signature, result) {
-      boundedTailReadCache.delete(key);
-      boundedTailReadCache.set(key, { signature, result });
+    function writeBoundedTailCache(key2, signature, result) {
+      boundedTailReadCache.delete(key2);
+      boundedTailReadCache.set(key2, { signature, result });
       while (boundedTailReadCache.size > BOUNDED_TAIL_CACHE_MAX_ENTRIES) {
         const oldest = boundedTailReadCache.keys().next().value;
         if (oldest === void 0) break;
@@ -56824,21 +56789,21 @@ ${lastSnapshot}`;
       return shouldScheduleSavedHistoryRollup(size);
     }
     function scheduleSavedHistoryRollup(agentType, historySessionId) {
-      const key = `${agentType}:${historySessionId}`;
-      if (!historySessionId || savedHistoryRollupInFlight.has(key)) return;
-      savedHistoryRollupInFlight.add(key);
+      const key2 = `${agentType}:${historySessionId}`;
+      if (!historySessionId || savedHistoryRollupInFlight.has(key2)) return;
+      savedHistoryRollupInFlight.add(key2);
       setTimeout(() => {
         try {
           new ChatHistoryWriter().compactHistorySession(agentType, historySessionId);
         } finally {
-          savedHistoryRollupInFlight.delete(key);
+          savedHistoryRollupInFlight.delete(key2);
         }
       }, 0);
     }
     function scheduleSavedHistoryBackgroundRefresh(agentType, dir) {
-      const key = `${agentType}:${dir}`;
-      if (savedHistoryBackgroundRefresh.has(key)) return;
-      savedHistoryBackgroundRefresh.add(key);
+      const key2 = `${agentType}:${dir}`;
+      if (savedHistoryBackgroundRefresh.has(key2)) return;
+      savedHistoryBackgroundRefresh.add(key2);
       setTimeout(() => {
         try {
           if (!fs6.existsSync(dir)) return;
@@ -56858,7 +56823,7 @@ ${lastSnapshot}`;
           }
         } catch {
         } finally {
-          savedHistoryBackgroundRefresh.delete(key);
+          savedHistoryBackgroundRefresh.delete(key2);
         }
       }, 0);
     }
@@ -57624,14 +57589,14 @@ ${lastSnapshot}`;
         return false;
       }
     }
-    function getNativeHistoryScriptName(canonicalHistory, key) {
-      const configured = canonicalHistory?.scripts?.[key];
+    function getNativeHistoryScriptName(canonicalHistory, key2) {
+      const configured = canonicalHistory?.scripts?.[key2];
       if (typeof configured === "string" && configured.trim()) return configured.trim();
-      return key === "readSession" ? "readNativeHistory" : "listNativeHistory";
+      return key2 === "readSession" ? "readNativeHistory" : "listNativeHistory";
     }
-    function getProviderNativeHistoryScript(scripts, canonicalHistory, key) {
+    function getProviderNativeHistoryScript(scripts, canonicalHistory, key2) {
       if (!canonicalHistory?.scripts) return null;
-      const fn = scripts?.[getNativeHistoryScriptName(canonicalHistory, key)];
+      const fn = scripts?.[getNativeHistoryScriptName(canonicalHistory, key2)];
       return typeof fn === "function" ? fn : null;
     }
     function normalizeProviderNativeHistoryRecords(agentType, historySessionId, records) {
@@ -58355,11 +58320,11 @@ ${effect.notification.body || ""}`.trim();
         throw new Error(`${source}: controlValues must be an object when provided`);
       }
       const normalized = {};
-      for (const [key, value] of Object.entries(controlValues)) {
+      for (const [key2, value] of Object.entries(controlValues)) {
         if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
-          throw new Error(`${source}: controlValues.${key} must be string, number, or boolean`);
+          throw new Error(`${source}: controlValues.${key2} must be string, number, or boolean`);
         }
-        normalized[key] = value;
+        normalized[key2] = value;
       }
       return normalized;
     }
@@ -59106,7 +59071,7 @@ ${effect.notification.body || ""}`.trim();
           for (const [ide, ports] of Object.entries(portMap)) {
             const primaryPort = ports[0];
             const alreadyConnected = [...this.ctx.cdpManagers.entries()].some(
-              ([key, m]) => m.isConnected && (key === ide || key.startsWith(ide + "_"))
+              ([key2, m]) => m.isConnected && (key2 === ide || key2.startsWith(ide + "_"))
             );
             if (alreadyConnected) continue;
             if (this.opts.multiWindow) {
@@ -59278,8 +59243,8 @@ ${effect.notification.body || ""}`.trim();
         for (let i = 0; i < targets.length; i++) {
           const target = targets[i];
           let alreadyTracked = false;
-          for (const [key, m] of cdpManagers.entries()) {
-            if ((key === ide || key.startsWith(`${ide}_`)) && m.targetId === target.id) {
+          for (const [key2, m] of cdpManagers.entries()) {
+            if ((key2 === ide || key2.startsWith(`${ide}_`)) && m.targetId === target.id) {
               alreadyTracked = true;
               break;
             }
@@ -59311,29 +59276,29 @@ ${effect.notification.body || ""}`.trim();
       async pruneStaleManagers(port, ide, targets) {
         const trackedTargetIds = new Set(targets.map((target) => target.id));
         const removals = [];
-        for (const [key, manager] of this.config.cdpManagers.entries()) {
-          if (!(key === ide || key.startsWith(`${ide}_`))) continue;
+        for (const [key2, manager] of this.config.cdpManagers.entries()) {
+          if (!(key2 === ide || key2.startsWith(`${ide}_`))) continue;
           if (manager.getPort() !== port) continue;
           if (targets.length === 0) {
-            removals.push({ key, manager, reason: "ide_closed" });
+            removals.push({ key: key2, manager, reason: "ide_closed" });
             continue;
           }
           if (manager.targetId && !trackedTargetIds.has(manager.targetId)) {
-            removals.push({ key, manager, reason: "target_closed" });
+            removals.push({ key: key2, manager, reason: "target_closed" });
             continue;
           }
-          if (key === ide && !manager.targetId && targets.length > 1) {
-            removals.push({ key, manager, reason: "target_rekeyed" });
+          if (key2 === ide && !manager.targetId && targets.length > 1) {
+            removals.push({ key: key2, manager, reason: "target_rekeyed" });
           }
         }
-        for (const { key, manager, reason } of removals) {
+        for (const { key: key2, manager, reason } of removals) {
           try {
             manager.disconnect();
           } catch {
           }
-          this.config.cdpManagers.delete(key);
-          LOG2.info("IDE", `Detached window: ${key} (${reason})`);
-          await this.config.onDisconnected?.(ide, manager, key, reason);
+          this.config.cdpManagers.delete(key2);
+          LOG2.info("IDE", `Detached window: ${key2} (${reason})`);
+          await this.config.onDisconnected?.(ide, manager, key2, reason);
         }
       }
       // ─── Periodic scanning ───
@@ -59637,7 +59602,7 @@ ${effect.notification.body || ""}`.trim();
         if (Array.isArray(value)) return value.map((entry) => sanitizeTraceValue(entry, traceContent));
         if (value && typeof value === "object") {
           return Object.fromEntries(
-            Object.entries(value).map(([key, nested]) => [key, sanitizeTraceValue(nested, traceContent)])
+            Object.entries(value).map(([key2, nested]) => [key2, sanitizeTraceValue(nested, traceContent)])
           );
         }
         return value;
@@ -59646,7 +59611,7 @@ ${effect.notification.body || ""}`.trim();
       if (Array.isArray(value)) return value.map((entry) => sanitizeTraceValue(entry, traceContent));
       if (value && typeof value === "object") {
         return Object.fromEntries(
-          Object.entries(value).map(([key, nested]) => [key, sanitizeTraceValue(nested, traceContent)])
+          Object.entries(value).map(([key2, nested]) => [key2, sanitizeTraceValue(nested, traceContent)])
         );
       }
       return value;
@@ -59950,8 +59915,8 @@ ${effect.notification.body || ""}`.trim();
     }
     function isSupersetOf(candidate, required2) {
       if (required2.size === 0) return true;
-      for (const key of required2) {
-        if (!candidate.has(key)) return false;
+      for (const key2 of required2) {
+        if (!candidate.has(key2)) return false;
       }
       return true;
     }
@@ -59962,17 +59927,17 @@ ${effect.notification.body || ""}`.trim();
     var ChatSourceRegistry = class {
       records = /* @__PURE__ */ new Map();
       /** Snapshot of current state for diagnostics. Does not mutate. */
-      getState(key) {
-        return this.records.get(key)?.state ?? INITIAL_CHAT_SOURCE_STATE;
+      getState(key2) {
+        return this.records.get(key2)?.state ?? INITIAL_CHAT_SOURCE_STATE;
       }
       /** Recent transitions, newest last. Empty array when nothing has happened. */
-      getTransitions(key) {
-        return this.records.get(key)?.transitions ?? [];
+      getTransitions(key2) {
+        return this.records.get(key2)?.transitions ?? [];
       }
       /** Drop a session. Caller should invoke this when the session is destroyed
        *  to avoid unbounded growth across long-lived daemons. */
-      clear(key) {
-        this.records.delete(key);
+      clear(key2) {
+        this.records.delete(key2);
       }
       /** Drop all sessions. Test helper. */
       clearAll() {
@@ -59984,15 +59949,15 @@ ${effect.notification.body || ""}`.trim();
        * under `key`; callers may treat the decision as authoritative without
        * re-reading.
        */
-      observe(key, observation, at = Date.now()) {
-        const prev = this.records.get(key);
+      observe(key2, observation, at = Date.now()) {
+        const prev = this.records.get(key2);
         const prevState = prev?.state ?? INITIAL_CHAT_SOURCE_STATE;
         const prevLockedSince = prev?.lockedSince;
         const result = transitionChatSourceState(prevState, observation, at, prevLockedSince);
         const transitions = prev?.transitions ?? [];
         const nextTransitions = appendTransition(transitions, result.transition);
         const lockedSince = result.lockState.lockedSince;
-        this.records.set(key, {
+        this.records.set(key2, {
           state: result.next,
           lockedSince,
           transitions: nextTransitions
@@ -60673,8 +60638,8 @@ ${effect.notification.body || ""}`.trim();
       });
       return { ...history, lookup: "workspace" };
     }
-    function shouldPreserveReadChatPayloadField(key) {
-      return key === "messageSource" || key === "transcriptProvenance";
+    function shouldPreserveReadChatPayloadField(key2) {
+      return key2 === "messageSource" || key2 === "transcriptProvenance";
     }
     function updateMessageSourceReturnedCount(value, returnedMessageCount) {
       if (!value || typeof value !== "object" || Array.isArray(value)) return value;
@@ -60844,7 +60809,7 @@ ${effect.notification.body || ""}`.trim();
       const visibleMessages = includeActivity ? filteredMessages.filter((m) => isUserFacingChatMessage(m) || isActivityChatMessage(m)) : filterUserFacingChatMessages(filteredMessages);
       const sync = buildFullTail(visibleMessages, normalizeReadChatTailLimit(args));
       const hiddenMsgCount = Math.max(0, messages.length - visibleMessages.length);
-      const preservedPayloadFields = Object.fromEntries(Object.entries(payload).filter(([key]) => shouldPreserveReadChatPayloadField(key)));
+      const preservedPayloadFields = Object.fromEntries(Object.entries(payload).filter(([key2]) => shouldPreserveReadChatPayloadField(key2)));
       if (preservedPayloadFields.messageSource) {
         preservedPayloadFields.messageSource = updateMessageSourceReturnedCount(preservedPayloadFields.messageSource, sync.messages.length);
       }
@@ -61594,8 +61559,8 @@ ${effect.notification.body || ""}`.trim();
       const record2 = value;
       const result = {};
       const entries = Object.entries(record2).slice(0, normalizedOptions.maxObjectKeys);
-      for (const [key, item] of entries) {
-        result[key] = sanitizeDebugBundleValue(item, normalizedOptions, depth + 1, key);
+      for (const [key2, item] of entries) {
+        result[key2] = sanitizeDebugBundleValue(item, normalizedOptions, depth + 1, key2);
       }
       const remaining = Object.keys(record2).length - entries.length;
       if (remaining > 0) result.__truncatedKeys = remaining;
@@ -61919,14 +61884,14 @@ ${effect.notification.body || ""}`.trim();
       if (typeof script !== "function") return null;
       return script(text);
     }
-    function isRecentDuplicateSend(key) {
+    function isRecentDuplicateSend(key2) {
       const now = Date.now();
       for (const [candidate, ts2] of recentSendByTarget.entries()) {
         if (now - ts2 > RECENT_SEND_WINDOW_MS) recentSendByTarget.delete(candidate);
       }
-      const previous = recentSendByTarget.get(key);
+      const previous = recentSendByTarget.get(key2);
       if (previous && now - previous <= RECENT_SEND_WINDOW_MS) return true;
-      recentSendByTarget.set(key, now);
+      recentSendByTarget.set(key2, now);
       return false;
     }
     function didProviderConfirmSend(result) {
@@ -62787,23 +62752,23 @@ ${effect.notification.body || ""}`.trim();
       try {
         switch (action) {
           case "input_key": {
-            const { type: evType, key, code, text, unmodifiedText, modifiers } = params;
+            const { type: evType, key: key2, code, text, unmodifiedText, modifiers } = params;
             const mod = typeof modifiers === "number" ? modifiers : 0;
-            const vk = KEY_TO_VK[key] || (key.length === 1 ? key.charCodeAt(0) : 0);
+            const vk = KEY_TO_VK[key2] || (key2.length === 1 ? key2.charCodeAt(0) : 0);
             if (evType === "char") {
               await h.getCdp().send("Input.dispatchKeyEvent", {
                 type: "char",
-                key,
+                key: key2,
                 code,
-                text: text || key,
-                unmodifiedText: unmodifiedText || text || key,
+                text: text || key2,
+                unmodifiedText: unmodifiedText || text || key2,
                 ...vk ? { windowsVirtualKeyCode: vk, nativeVirtualKeyCode: vk } : {},
                 ...mod ? { modifiers: mod } : {}
               });
             } else {
               await h.getCdp().send("Input.dispatchKeyEvent", {
                 type: "rawKeyDown",
-                key,
+                key: key2,
                 code,
                 ...text ? { text } : {},
                 ...vk ? { windowsVirtualKeyCode: vk, nativeVirtualKeyCode: vk } : {},
@@ -62811,7 +62776,7 @@ ${effect.notification.body || ""}`.trim();
               });
               await h.getCdp().send("Input.dispatchKeyEvent", {
                 type: "keyUp",
-                key,
+                key: key2,
                 code,
                 ...vk ? { windowsVirtualKeyCode: vk, nativeVirtualKeyCode: vk } : {},
                 ...mod ? { modifiers: mod } : {}
@@ -63202,21 +63167,21 @@ ${effect.notification.body || ""}`.trim();
     }
     async function handleSetProviderSetting(h, args) {
       const loader = h.ctx.providerLoader;
-      const { providerType, key, value } = args || {};
-      if (!providerType || !key || value === void 0) {
+      const { providerType, key: key2, value } = args || {};
+      if (!providerType || !key2 || value === void 0) {
         return { success: false, error: "providerType, key, and value are required" };
       }
-      const result = loader?.setSetting(providerType, key, value);
+      const result = loader?.setSetting(providerType, key2, value);
       if (result) {
         if (h.ctx.instanceManager) {
           const allSettings = loader?.getSettings(providerType) || {};
           const updated = h.ctx.instanceManager.updateInstanceSettings(providerType, allSettings);
-          LOG2.info("Command", `[set_provider_setting] ${providerType}.${key}=${JSON.stringify(value)} \u2192 ${updated} instance(s) updated`);
+          LOG2.info("Command", `[set_provider_setting] ${providerType}.${key2}=${JSON.stringify(value)} \u2192 ${updated} instance(s) updated`);
         }
-        await h.ctx.onProviderSettingChanged?.(providerType, key, value);
-        return { success: true, providerType, key, value };
+        await h.ctx.onProviderSettingChanged?.(providerType, key2, value);
+        return { success: true, providerType, key: key2, value };
       }
-      return { success: false, error: `Failed to set ${providerType}.${key} \u2014 invalid key, value, or not a public setting` };
+      return { success: false, error: `Failed to set ${providerType}.${key2} \u2014 invalid key, value, or not a public setting` };
     }
     function handleGetProviderSourceConfig(h, _args) {
       const loader = h.ctx.providerLoader;
@@ -63262,9 +63227,9 @@ ${effect.notification.body || ""}`.trim();
           normalizedArgs.mode = normalizedArgs.value;
         }
       }
-      for (const key of ["mode", "model", "message", "action", "button", "text", "sessionId", "value"]) {
-        if (key in normalizedArgs && !(key.toUpperCase() in normalizedArgs)) {
-          normalizedArgs[key.toUpperCase()] = normalizedArgs[key];
+      for (const key2 of ["mode", "model", "message", "action", "button", "text", "sessionId", "value"]) {
+        if (key2 in normalizedArgs && !(key2.toUpperCase() in normalizedArgs)) {
+          normalizedArgs[key2.toUpperCase()] = normalizedArgs[key2];
         }
       }
       return normalizedArgs;
@@ -63660,10 +63625,10 @@ ${effect.notification.body || ""}`.trim();
         "value"
       ];
       const entries = [];
-      for (const key of preferredKeys) {
-        if (!(key in args) || args[key] === void 0) continue;
-        const value = key === "text" || key === "message" ? `${String(args[key] || "").length} chars` : key === "data" ? `${String(args[key] || "").length} chars` : summarizeLogValue(args[key]);
-        entries.push(`${key}=${value}`);
+      for (const key2 of preferredKeys) {
+        if (!(key2 in args) || args[key2] === void 0) continue;
+        const value = key2 === "text" || key2 === "message" ? `${String(args[key2] || "").length} chars` : key2 === "data" ? `${String(args[key2] || "").length} chars` : summarizeLogValue(args[key2]);
+        entries.push(`${key2}=${value}`);
       }
       return entries.length ? entries.join(" ") : "{...}";
     }
@@ -63715,12 +63680,12 @@ ${effect.notification.body || ""}`.trim();
        * Get provider module — _currentProviderType (agentType priority) use.
        */
       getProvider(overrideType) {
-        const key = overrideType || this._currentRoute.providerType || this._currentRoute.session?.providerType || this._currentRoute.managerKey;
-        if (!key || !this._ctx.providerLoader) return void 0;
-        const result = this._ctx.providerLoader.resolve(key);
+        const key2 = overrideType || this._currentRoute.providerType || this._currentRoute.session?.providerType || this._currentRoute.managerKey;
+        if (!key2 || !this._ctx.providerLoader) return void 0;
+        const result = this._ctx.providerLoader.resolve(key2);
         if (result) return result;
-        const baseType = key.split("_")[0];
-        if (baseType !== key) return this._ctx.providerLoader.resolve(baseType);
+        const baseType = key2.split("_")[0];
+        if (baseType !== key2) return this._ctx.providerLoader.resolve(baseType);
         return void 0;
       }
       /** Get a provider script by name from ProviderLoader. */
@@ -63778,11 +63743,11 @@ ${effect.notification.body || ""}`.trim();
         return this._ctx.adapters.get(target) || null;
       }
       // ─── Private helpers ──────────────────────────────
-      inferProviderType(key) {
-        if (!key) return void 0;
-        const session = this._ctx.sessionRegistry?.get(key);
+      inferProviderType(key2) {
+        if (!key2) return void 0;
+        const session = this._ctx.sessionRegistry?.get(key2);
         if (session?.providerType) return session.providerType;
-        return key.split("_")[0];
+        return key2.split("_")[0];
       }
       resolveRoute(args) {
         const targetSessionId = typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : "";
@@ -65468,16 +65433,16 @@ ${formatManifestValidationIssues2(validation.issues)}`,
               const m = matchAppend || matchOverride;
               if (!m) continue;
               const isAppend = !!matchAppend;
-              const key = m[1];
+              const key2 = m[1];
               const full = path43.join(dir, name);
               let content = "";
               try {
                 content = fs38.readFileSync(full, "utf8");
               } catch {
               }
-              if (!entries[key]) entries[key] = { override: "", append: "" };
-              if (isAppend) entries[key].append = content;
-              else entries[key].override = content;
+              if (!entries[key2]) entries[key2] = { override: "", append: "" };
+              if (isAppend) entries[key2].append = content;
+              else entries[key2].override = content;
             }
           }
         } catch (error48) {
@@ -65489,14 +65454,14 @@ ${formatManifestValidationIssues2(validation.issues)}`,
         const fs38 = await import("fs");
         const path43 = await import("path");
         const os30 = await import("os");
-        const key = typeof args?.key === "string" ? args.key.trim() : "";
+        const key2 = typeof args?.key === "string" ? args.key.trim() : "";
         const kind = args?.kind === "append" ? "append" : "override";
         const content = typeof args?.content === "string" ? args.content : "";
-        if (!key || !/^[a-zA-Z0-9_.-]+$/.test(key)) {
+        if (!key2 || !/^[a-zA-Z0-9_.-]+$/.test(key2)) {
           return { success: false, error: "key must match [a-zA-Z0-9_.-]+" };
         }
         const dir = path43.join(os30.homedir(), ".adhdev", "coordinator-prompts");
-        const filename = kind === "append" ? `${key}.append.md` : `${key}.md`;
+        const filename = kind === "append" ? `${key2}.append.md` : `${key2}.md`;
         const full = path43.join(dir, filename);
         try {
           fs38.mkdirSync(dir, { recursive: true });
@@ -65505,7 +65470,7 @@ ${formatManifestValidationIssues2(validation.issues)}`,
           } else if (fs38.existsSync(full)) {
             fs38.unlinkSync(full);
           }
-          return { success: true, path: full, kind, key };
+          return { success: true, path: full, kind, key: key2 };
         } catch (error48) {
           return { success: false, error: error48?.message || String(error48) };
         }
@@ -66434,7 +66399,7 @@ ${body}
       {
         name: "key_value_secret",
         pattern: /\b([A-Z0-9_]*(?:SECRET|TOKEN|API[_-]?KEY|PASSWORD|PASSWD|PRIVATE[_-]?KEY|CREDENTIAL|CLIENT[_-]?SECRET)[A-Z0-9_]*)(\s*[:=]\s*)(["']?)([^\s"',;]+)\3/gi,
-        replace: (_m, key, delim, quote) => `${key}${delim}${quote}${MASK}${quote}`
+        replace: (_m, key2, delim, quote) => `${key2}${delim}${quote}${MASK}${quote}`
       },
       // Authorization: Bearer <token>
       {
@@ -66764,7 +66729,7 @@ ${body}
     }
     function applyPreLaunchTrust(trust, workingDir) {
       const settingsPath = expandHome2(trust.settings_path);
-      const key = trust.key;
+      const key2 = trust.key;
       const real = realWorkspacePath(workingDir);
       try {
         let parsed = {};
@@ -66777,18 +66742,18 @@ ${body}
             }
           }
         }
-        const existing = parsed[key];
+        const existing = parsed[key2];
         const list = Array.isArray(existing) ? existing.filter((v) => typeof v === "string") : [];
         if (list.includes(real)) {
           LOG2.debug("pre-launch-trust", `[${trust.settings_path}] ${real} already trusted \u2014 no change`);
           return null;
         }
         list.push(real);
-        parsed[key] = list;
+        parsed[key2] = list;
         fs14.mkdirSync(path222.dirname(settingsPath), { recursive: true });
         fs14.writeFileSync(settingsPath, `${JSON.stringify(parsed, null, 2)}
 `, "utf8");
-        LOG2.info("pre-launch-trust", `pre-trusted workspace in ${trust.settings_path} (key="${key}")`);
+        LOG2.info("pre-launch-trust", `pre-trusted workspace in ${trust.settings_path} (key="${key2}")`);
         return real;
       } catch (err) {
         LOG2.warn("pre-launch-trust", `failed to pre-trust workspace in ${trust.settings_path}: ${err.message}`);
@@ -68389,8 +68354,8 @@ ${body}
         }
         let end = i;
         while (end < expr.length && expr[end] !== "." && expr[end] !== "[") end += 1;
-        const key = expr.slice(i, end);
-        cur = cur[key];
+        const key2 = expr.slice(i, end);
+        cur = cur[key2];
         i = end;
       }
       return cur;
@@ -70351,8 +70316,8 @@ ${body}
       /** Drop user-input ack entries older than the dedup window so the map can't grow unbounded. */
       pruneRecentUserInputAcks(now) {
         if (this.recentUserInputAcks.size <= 1) return;
-        for (const [key, at] of this.recentUserInputAcks) {
-          if (now - at > USER_INPUT_ACK_DEDUP_WINDOW_MS) this.recentUserInputAcks.delete(key);
+        for (const [key2, at] of this.recentUserInputAcks) {
+          if (now - at > USER_INPUT_ACK_DEDUP_WINDOW_MS) this.recentUserInputAcks.delete(key2);
         }
       }
       dispose() {
@@ -71556,8 +71521,8 @@ ${effect.notification.body || ""}`.trim();
         };
         const isRuntimeOverlay = (entry) => {
           if (entry.source !== "runtime") return false;
-          const key = typeof entry.runtimeKey === "string" ? entry.runtimeKey.trim().toLowerCase() : "";
-          if (key.startsWith("auto_approval:")) return true;
+          const key2 = typeof entry.runtimeKey === "string" ? entry.runtimeKey.trim().toLowerCase() : "";
+          if (key2.startsWith("auto_approval:")) return true;
           return !isUserFacingChatMessage(entry.message);
         };
         const shouldKeepParsedBeforeUntimedRuntime = (message) => {
@@ -73154,16 +73119,16 @@ ${rawInput}` : rawInput;
     function hasCliArg(args, flag) {
       return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
     }
-    function hasConfigOverride(args, key) {
+    function hasConfigOverride(args, key2) {
       for (let index = 0; index < args.length; index += 1) {
         const arg = args[index];
         const next = args[index + 1];
         if ((arg === "-c" || arg === "--config") && typeof next === "string") {
-          if (next === key || next.startsWith(`${key}=`) || next.startsWith(`${key}.`)) return true;
+          if (next === key2 || next.startsWith(`${key2}=`) || next.startsWith(`${key2}.`)) return true;
         }
         if (arg.startsWith("--config=")) {
           const value = arg.slice("--config=".length);
-          if (value === key || value.startsWith(`${key}=`) || value.startsWith(`${key}.`)) return true;
+          if (value === key2 || value.startsWith(`${key2}=`) || value.startsWith(`${key2}.`)) return true;
         }
       }
       return false;
@@ -73180,10 +73145,10 @@ ${rawInput}` : rawInput;
       const cliArgs = Array.isArray(input.cliArgs) ? [...input.cliArgs] : [];
       const env2 = { ...input.env || {} };
       const envUnsets = new Set(DEFAULT_COORDINATOR_DELEGATED_ENV_UNSETS);
-      for (const key of input.isolation?.env?.unset || []) {
-        if (typeof key === "string" && key.trim()) envUnsets.add(key.trim());
+      for (const key2 of input.isolation?.env?.unset || []) {
+        if (typeof key2 === "string" && key2.trim()) envUnsets.add(key2.trim());
       }
-      for (const key of envUnsets) env2[key] = "";
+      for (const key2 of envUnsets) env2[key2] = "";
       for (const rule of input.isolation?.args || []) {
         if (!rule || typeof rule !== "object") continue;
         if (rule.mode === "empty_mcp_config") {
@@ -73196,9 +73161,9 @@ ${rawInput}` : rawInput;
           continue;
         }
         if (rule.mode === "config_override") {
-          const key = String(rule.dedupeKey || rule.key || "").trim();
+          const key2 = String(rule.dedupeKey || rule.key || "").trim();
           const flag = String(rule.flag || "").trim();
-          if (!key || !flag || hasConfigOverride(cliArgs, key)) continue;
+          if (!key2 || !flag || hasConfigOverride(cliArgs, key2)) continue;
           cliArgs.unshift(flag, `${rule.key}=${rule.value}`);
         }
       }
@@ -73404,12 +73369,12 @@ ${rawInput}` : rawInput;
         }
         throw new Error(`No CLI provider found for '${cliType}'. Create a provider.js in providers/cli/${cliType}/`);
       }
-      startCliExitMonitor(key, cliType) {
+      startCliExitMonitor(key2, cliType) {
         const sessionRegistry = this.deps.getSessionRegistry?.() || null;
         const instanceManager = this.deps.getInstanceManager();
         const checkStopped = setInterval(() => {
           try {
-            const adapter = this.adapters.get(key);
+            const adapter = this.adapters.get(key2);
             if (!adapter) {
               clearInterval(checkStopped);
               return;
@@ -73418,12 +73383,12 @@ ${rawInput}` : rawInput;
             if (status?.status === "stopped" || status?.status === "error") {
               clearInterval(checkStopped);
               setTimeout(() => {
-                if (this.adapters.has(key)) {
-                  this.adapters.delete(key);
-                  this.deps.removeAgentTracking(key);
-                  sessionRegistry?.unregisterByInstanceKey(key);
-                  instanceManager?.removeInstance(key);
-                  unregisterMeshCoordinator(key);
+                if (this.adapters.has(key2)) {
+                  this.adapters.delete(key2);
+                  this.deps.removeAgentTracking(key2);
+                  sessionRegistry?.unregisterByInstanceKey(key2);
+                  instanceManager?.removeInstance(key2);
+                  unregisterMeshCoordinator(key2);
                   LOG2.info("CLI", `\u{1F9F9} Auto-cleaned ${status.status} CLI: ${cliType}`);
                   this.deps.onStatusChange();
                 }
@@ -73433,21 +73398,21 @@ ${rawInput}` : rawInput;
           }
         }, 3e3);
       }
-      async registerCliInstance(key, normalizedType, cliType, resolvedDir, cliArgs, provider, settings, attachExisting = false, options) {
+      async registerCliInstance(key2, normalizedType, cliType, resolvedDir, cliArgs, provider, settings, attachExisting = false, options) {
         const instanceManager = this.deps.getInstanceManager();
         const sessionRegistry = this.deps.getSessionRegistry?.() || null;
         if (!instanceManager) throw new Error("InstanceManager not available");
         const transportFactory = this.getTransportFactory(
-          key,
+          key2,
           normalizedType,
           resolvedDir,
           cliArgs,
           options?.providerSessionId,
           attachExisting
         );
-        const cliInstance = new CliProviderInstance(provider, resolvedDir, cliArgs, key, transportFactory, options);
+        const cliInstance = new CliProviderInstance(provider, resolvedDir, cliArgs, key2, transportFactory, options);
         try {
-          await instanceManager.addInstance(key, cliInstance, {
+          await instanceManager.addInstance(key2, cliInstance, {
             serverConn: this.deps.getServerConn(),
             settings,
             onPtyData: (data) => {
@@ -73459,8 +73424,8 @@ ${rawInput}` : rawInput;
             parentSessionId: null,
             providerType: normalizedType,
             transport: "pty",
-            adapterKey: key,
-            instanceKey: key,
+            adapterKey: key2,
+            instanceKey: key2,
             workspace: resolvedDir,
             // attachExisting === true means we're restoring an already-spawned
             // hosted runtime after a daemon restart, not starting a fresh PTY.
@@ -73476,10 +73441,10 @@ ${rawInput}` : rawInput;
           });
         } catch (spawnErr) {
           LOG2.error("CLI", `[${cliType}] Spawn failed: ${spawnErr?.message}`);
-          instanceManager.removeInstance(key);
+          instanceManager.removeInstance(key2);
           throw new Error(`Failed to start ${provider.displayName || provider.name || cliType}: ${spawnErr?.message}`);
         }
-        this.adapters.set(key, cliInstance.getAdapter());
+        this.adapters.set(key2, cliInstance.getAdapter());
         const launchMeshNodeId = typeof settings?.meshNodeId === "string" ? settings.meshNodeId.trim() : "";
         const launchMeshNodeFor = typeof settings?.meshNodeFor === "string" ? settings.meshNodeFor.trim() : "";
         if (launchMeshNodeId || launchMeshNodeFor) {
@@ -73492,7 +73457,7 @@ ${rawInput}` : rawInput;
           } catch {
           }
         }
-        this.startCliExitMonitor(key, cliType);
+        this.startCliExitMonitor(key2, cliType);
       }
       // ─── Session start/management ──────────────────────────────
       async startSession(cliType, workingDir, cliArgs, initialModel, options) {
@@ -73509,11 +73474,11 @@ ${rawInput}` : rawInput;
 Enable and detect this provider from the Machine Providers page before starting a runtime.`
           );
         }
-        const key = crypto5.randomUUID();
+        const key2 = crypto5.randomUUID();
         {
           const coordinatorMeshId = options?.settingsOverride?.meshCoordinatorFor;
           if (typeof coordinatorMeshId === "string" && coordinatorMeshId.trim()) {
-            options = { ...options, extraEnv: { ...options?.extraEnv || {}, ADHDEV_COORDINATOR_SESSION_ID: key } };
+            options = { ...options, extraEnv: { ...options?.extraEnv || {}, ADHDEV_COORDINATOR_SESSION_ID: key2 } };
           }
         }
         const sessionRegistry = this.deps.getSessionRegistry?.() || null;
@@ -73533,7 +73498,7 @@ ${installInfo}`
           }
           console.log(colorize("cyan", `  \u{1F50C} Starting ACP agent: ${provider.name} (${provider.type}) in ${resolvedDir}`));
           const acpInstance = new AcpProviderInstance(resolvedProvider, resolvedDir, cliArgs);
-          await instanceManager2.addInstance(key, acpInstance, {
+          await instanceManager2.addInstance(key2, acpInstance, {
             settings: this.providerLoader.getSettings(normalizedType)
           });
           const sessionId = acpInstance.getInstanceId();
@@ -73542,11 +73507,11 @@ ${installInfo}`
             parentSessionId: null,
             providerType: normalizedType,
             transport: "acp",
-            adapterKey: key,
-            instanceKey: key,
+            adapterKey: key2,
+            instanceKey: key2,
             workspace: resolvedDir
           });
-          this.adapters.set(key, {
+          this.adapters.set(key2, {
             cliType: normalizedType,
             cliName: provider.name,
             workingDir: resolvedDir,
@@ -73554,7 +73519,7 @@ ${installInfo}`
             spawn: async () => {
             },
             shutdown: () => {
-              instanceManager2.removeInstance(key);
+              instanceManager2.removeInstance(key2);
             },
             sendMessage: async (text) => {
               const input = normalizeInputEnvelope(text);
@@ -73570,7 +73535,7 @@ ${installInfo}`
             },
             getPartialResponse: () => "",
             cancel: () => {
-              instanceManager2.removeInstance(key);
+              instanceManager2.removeInstance(key2);
             },
             isProcessing: () => false,
             isReady: () => true,
@@ -73624,7 +73589,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         if (provider && instanceManager) {
           const resolvedProvider = this.providerLoader.resolve(cliType, { version: cliInfo.version }) || provider;
           await this.registerCliInstance(
-            key,
+            key2,
             normalizedType,
             cliType,
             resolvedDir,
@@ -73654,7 +73619,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
             cliType,
             resolvedDir,
             resolvedCliArgs,
-            key,
+            key2,
             sessionBinding.providerSessionId,
             false,
             options?.extraEnv
@@ -73674,9 +73639,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
             const status = adapter.getStatus?.();
             if (status?.status === "stopped" || status?.status === "error") {
               setTimeout(() => {
-                if (this.adapters.get(key) === adapter) {
-                  this.adapters.delete(key);
-                  this.deps.removeAgentTracking(key);
+                if (this.adapters.get(key2) === adapter) {
+                  this.adapters.delete(key2);
+                  this.deps.removeAgentTracking(key2);
                   LOG2.info("CLI", `\u{1F9F9} Auto-cleaned ${status.status} CLI: ${adapter.cliType}`);
                   this.deps.onStatusChange();
                 }
@@ -73685,10 +73650,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
           });
           if (typeof adapter.setOnPtyData === "function") {
             adapter.setOnPtyData((data) => {
-              this.deps.getP2p()?.broadcastSessionOutput(key, data);
+              this.deps.getP2p()?.broadcastSessionOutput(key2, data);
             });
           }
-          this.adapters.set(key, adapter);
+          this.adapters.set(key2, adapter);
           console.log(colorize("green", `  \u2713 CLI started: ${cliInfo.displayName} v${cliInfo.version || "unknown"} in ${resolvedDir}`));
         }
         this.persistRecentActivity({
@@ -73698,20 +73663,20 @@ Run 'adhdev doctor' for detailed diagnostics.`
           providerSessionId: sessionBinding.providerSessionId,
           workspace: resolvedDir,
           summaryMetadata: buildLegacyModelModeSummaryMetadata({ model: initialModel }),
-          sessionId: key,
+          sessionId: key2,
           title: provider?.displayName || provider?.name || normalizedType
         });
         this.deps.onStatusChange();
         return {
-          runtimeSessionId: key,
+          runtimeSessionId: key2,
           providerSessionId: sessionBinding.providerSessionId
         };
       }
-      async stopSession(key) {
-        return this.stopSessionWithMode(key, "hard");
+      async stopSession(key2) {
+        return this.stopSessionWithMode(key2, "hard");
       }
-      async stopSessionWithMode(key, mode) {
-        const adapter = this.adapters.get(key);
+      async stopSessionWithMode(key2, mode) {
+        const adapter = this.adapters.get(key2);
         if (adapter) {
           try {
             if (mode === "save" && typeof adapter.saveAndStop === "function") {
@@ -73722,21 +73687,21 @@ Run 'adhdev doctor' for detailed diagnostics.`
           } catch (e) {
             LOG2.warn("CLI", `Shutdown error for ${adapter.cliType}: ${e?.message} (force-cleaning)`);
           }
-          this.adapters.delete(key);
-          this.deps.removeAgentTracking(key);
-          this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
-          this.deps.getInstanceManager()?.removeInstance(key);
-          unregisterMeshCoordinator(key);
+          this.adapters.delete(key2);
+          this.deps.removeAgentTracking(key2);
+          this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key2);
+          this.deps.getInstanceManager()?.removeInstance(key2);
+          unregisterMeshCoordinator(key2);
           LOG2.info("CLI", `\u{1F6D1} Agent stopped: ${adapter.cliType} in ${adapter.workingDir}`);
           this.deps.onStatusChange();
         } else {
           const im = this.deps.getInstanceManager();
           if (im) {
-            this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
-            im.removeInstance(key);
-            this.deps.removeAgentTracking(key);
-            unregisterMeshCoordinator(key);
-            LOG2.warn("CLI", `\u{1F9F9} Force-removed orphan entry: ${key}`);
+            this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key2);
+            im.removeInstance(key2);
+            this.deps.removeAgentTracking(key2);
+            unregisterMeshCoordinator(key2);
+            LOG2.warn("CLI", `\u{1F9F9} Force-removed orphan entry: ${key2}`);
             this.deps.onStatusChange();
           }
         }
@@ -73764,8 +73729,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
         for (const r of sessions) {
           if (!r?.runtimeId || !r?.cliType || !r?.workspace) continue;
           restoredRuntimeIds.add(r.runtimeId);
-          const key = `${r.workspace}::${r.cliType}`;
-          workspaceTypeCounts.set(key, (workspaceTypeCounts.get(key) || 0) + 1);
+          const key2 = `${r.workspace}::${r.cliType}`;
+          workspaceTypeCounts.set(key2, (workspaceTypeCounts.get(key2) || 0) + 1);
         }
         for (const record2 of sessions) {
           if (!record2?.runtimeId || !record2?.cliType || !record2?.workspace) continue;
@@ -74119,7 +74084,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               });
             }
             if (!found) throw new Error(`CLI agent not running: ${agentType}`);
-            const { adapter, key } = found;
+            const { adapter, key: key2 } = found;
             if (action === "send_chat") {
               let currentStatus = getEffectiveAgentSendStatus(adapter);
               if (currentStatus === "starting" && await waitForZeroMessageStartingLaunch(adapter)) {
@@ -74129,7 +74094,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               }
               const meshContext = args?.meshContext;
               if (meshContext && typeof meshContext === "object" && typeof meshContext.meshId === "string" && meshContext.meshId) {
-                const targetInstanceId = key;
+                const targetInstanceId = key2;
                 try {
                   this.deps.getInstanceManager()?.attachMeshAssignmentToInstance(targetInstanceId, {
                     meshId: meshContext.meshId,
@@ -74161,7 +74126,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               } else {
                 await adapter.sendMessage(message);
               }
-              const targetInstance = this.deps.getInstanceManager()?.getInstance(key);
+              const targetInstance = this.deps.getInstanceManager()?.getInstance(key2);
               targetInstance?.recordAcknowledgedUserInput?.(input);
               return {
                 success: true,
@@ -74173,7 +74138,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               if (typeof adapter.clearHistory === "function") adapter.clearHistory();
               return { success: true, cleared: true };
             } else if (action === "stop") {
-              await this.stopSession(key);
+              await this.stopSession(key2);
               return { success: true, stopped: true };
             }
             throw new Error(`Unknown action: ${action}`);
@@ -74437,9 +74402,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
       } else if (!["ide", "extension", "cli", "acp"].includes(String(provider.category))) {
         errors.push(`Invalid category: ${String(provider.category)}`);
       }
-      for (const key of Object.keys(provider)) {
-        if (!KNOWN_PROVIDER_FIELDS.has(key)) {
-          warnings.push(`Unknown provider field: ${key}`);
+      for (const key2 of Object.keys(provider)) {
+        if (!KNOWN_PROVIDER_FIELDS.has(key2)) {
+          warnings.push(`Unknown provider field: ${key2}`);
         }
       }
       if (provider.disableUpstream !== void 0) {
@@ -74584,10 +74549,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
         return;
       }
       const scriptConfig = scripts;
-      for (const key of ["readSession", "listSessions"]) {
-        const value = scriptConfig[key];
+      for (const key2 of ["readSession", "listSessions"]) {
+        const value = scriptConfig[key2];
         if (typeof value !== "string" || !value.trim()) {
-          errors.push(`nativeHistory.scripts.${key} must be a non-empty string`);
+          errors.push(`nativeHistory.scripts.${key2} must be a non-empty string`);
         }
       }
     }
@@ -74622,10 +74587,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
       if (format !== void 0 && !["claude_mcp_json", "hermes_config_yaml"].includes(String(format))) {
         errors.push("meshCoordinator.mcpConfig.format must be one of: claude_mcp_json, hermes_config_yaml");
       }
-      for (const key of ["path", "serverName", "configPathCommand", "instructions", "template"]) {
-        const value = config2[key];
+      for (const key2 of ["path", "serverName", "configPathCommand", "instructions", "template"]) {
+        const value = config2[key2];
         if (value !== void 0 && (typeof value !== "string" || !value.trim())) {
-          errors.push(`meshCoordinator.mcpConfig.${key} must be a non-empty string when provided`);
+          errors.push(`meshCoordinator.mcpConfig.${key2} must be a non-empty string when provided`);
         }
       }
       if (config2.requiresRestart !== void 0 && typeof config2.requiresRestart !== "boolean") {
@@ -74661,7 +74626,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           errors.push("meshCoordinator.delegatedWorkerIsolation.env must be an object");
         } else {
           const unset = env2.unset;
-          if (unset !== void 0 && (!Array.isArray(unset) || unset.some((key) => typeof key !== "string" || !key.trim()))) {
+          if (unset !== void 0 && (!Array.isArray(unset) || unset.some((key2) => typeof key2 !== "string" || !key2.trim()))) {
             errors.push("meshCoordinator.delegatedWorkerIsolation.env.unset must be an array of non-empty strings");
           }
         }
@@ -74684,16 +74649,16 @@ Run 'adhdev doctor' for detailed diagnostics.`
           errors.push(`${prefix}.mode must be one of: empty_mcp_config, config_override`);
           continue;
         }
-        for (const key of mode === "empty_mcp_config" ? ["flag"] : ["flag", "key", "value"]) {
-          const value = item[key];
+        for (const key2 of mode === "empty_mcp_config" ? ["flag"] : ["flag", "key", "value"]) {
+          const value = item[key2];
           if (typeof value !== "string" || !value.trim()) {
-            errors.push(`${prefix}.${key} must be a non-empty string`);
+            errors.push(`${prefix}.${key2} must be a non-empty string`);
           }
         }
-        for (const key of ["strictFlag", "dedupeKey"]) {
-          const value = item[key];
+        for (const key2 of ["strictFlag", "dedupeKey"]) {
+          const value = item[key2];
           if (value !== void 0 && (typeof value !== "string" || !value.trim())) {
-            errors.push(`${prefix}.${key} must be a non-empty string when provided`);
+            errors.push(`${prefix}.${key2} must be a non-empty string when provided`);
           }
         }
       }
@@ -76900,9 +76865,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
       reload() {
         this.log("Reloading all providers...");
         this.scriptsCache.clear();
-        for (const key of Object.keys(require.cache)) {
-          if (key.includes("providers") && (key.endsWith(".js") || key.endsWith(".json"))) {
-            delete require.cache[key];
+        for (const key2 of Object.keys(require.cache)) {
+          if (key2.includes("providers") && (key2.endsWith(".js") || key2.endsWith(".json"))) {
+            delete require.cache[key2];
           }
         }
         this.loadAll();
@@ -77210,7 +77175,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       */
       getPublicSettings(type) {
         const settings = this.getSettingsSchema(type);
-        return Object.entries(settings).filter(([, def]) => def.public === true).map(([key, def]) => ({ key, ...def }));
+        return Object.entries(settings).filter(([, def]) => def.public === true).map(([key2, def]) => ({ key: key2, ...def }));
       }
       /**
       * Get public settings schema for all providers
@@ -77226,23 +77191,23 @@ Run 'adhdev doctor' for detailed diagnostics.`
       /**
       * Resolved setting value for a provider (default + user override)
       */
-      getSettingValue(type, key) {
+      getSettingValue(type, key2) {
         const providerType = this.resolveAlias(type);
         const machineConfig = this.getMachineProviderConfig(providerType);
-        if (key === "enabled") {
+        if (key2 === "enabled") {
           return machineConfig.enabled === true;
         }
-        if (key === "executablePath") {
+        if (key2 === "executablePath") {
           return machineConfig.executable || "";
         }
-        if (key === "executableArgs") {
+        if (key2 === "executableArgs") {
           const args = machineConfig.args;
           return args ? args.map((arg) => /\s/.test(arg) ? JSON.stringify(arg) : arg).join(" ") : "";
         }
-        const schemaDef = this.getSettingsSchema(providerType)[key];
+        const schemaDef = this.getSettingsSchema(providerType)[key2];
         const defaultVal = schemaDef ? schemaDef.default : void 0;
         const config2 = this.readConfig();
-        const userVal = config2?.providerSettings?.[providerType]?.[key];
+        const userVal = config2?.providerSettings?.[providerType]?.[key2];
         return userVal !== void 0 ? userVal : defaultVal;
       }
       /**
@@ -77252,17 +77217,17 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const providerType = this.resolveAlias(type);
         const settings = this.getSettingsSchema(providerType);
         const result = {};
-        for (const [key] of Object.entries(settings)) {
-          result[key] = this.getSettingValue(providerType, key);
+        for (const [key2] of Object.entries(settings)) {
+          result[key2] = this.getSettingValue(providerType, key2);
         }
         return result;
       }
       /**
       * Save provider setting value (writes to config.json)
       */
-      setSetting(type, key, value) {
+      setSetting(type, key2, value) {
         const providerType = this.resolveAlias(type);
-        const schemaDef = this.getSettingsSchema(providerType)[key];
+        const schemaDef = this.getSettingsSchema(providerType)[key2];
         if (!schemaDef) return false;
         if (!schemaDef.public) return false;
         if (schemaDef.type === "boolean" && typeof value !== "boolean") return false;
@@ -77273,13 +77238,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
           if (schemaDef.max !== void 0 && value > schemaDef.max) return false;
         }
         if (schemaDef.type === "select" && schemaDef.options && !schemaDef.options.includes(value)) return false;
-        if (key === "enabled") {
+        if (key2 === "enabled") {
           return this.setMachineProviderEnabled(providerType, value);
         }
-        if (key === "executablePath") {
+        if (key2 === "executablePath") {
           return this.setMachineProviderConfig(providerType, { executable: value });
         }
-        if (key === "executableArgs") {
+        if (key2 === "executableArgs") {
           return this.setMachineProviderConfig(providerType, {
             args: value.trim() ? this.parseArgsSetting(value) : void 0
           });
@@ -77289,17 +77254,17 @@ Run 'adhdev doctor' for detailed diagnostics.`
         try {
           if (!config2.providerSettings) config2.providerSettings = {};
           if (!config2.providerSettings[providerType]) config2.providerSettings[providerType] = {};
-          config2.providerSettings[providerType][key] = value;
+          config2.providerSettings[providerType][key2] = value;
           this.writeConfig(config2);
-          this.log(`Setting updated: ${providerType}.${key} = ${JSON.stringify(value)}`);
+          this.log(`Setting updated: ${providerType}.${key2} = ${JSON.stringify(value)}`);
           return true;
         } catch (e) {
           this.log(`Failed to save setting: ${e.message}`);
           return false;
         }
       }
-      getOptionalStringSetting(type, key) {
-        const value = this.getSettingValue(type, key);
+      getOptionalStringSetting(type, key2) {
+        const value = this.getSettingValue(type, key2);
         if (typeof value !== "string") return null;
         const trimmed = value.trim();
         return trimmed ? trimmed : null;
@@ -77479,7 +77444,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               try {
                 let content = fs25.readFileSync(filePath, "utf-8");
                 if (args[0] && typeof args[0] === "object") {
-                  for (const [key, val] of Object.entries(args[0])) {
+                  for (const [key2, val] of Object.entries(args[0])) {
                     let v = val;
                     if (typeof v === "string") {
                       if (!v.startsWith('"') && !v.startsWith("'") && !v.startsWith("`")) {
@@ -77488,7 +77453,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                     } else {
                       v = JSON.stringify(v);
                     }
-                    const re = new RegExp(`\\$\\{\\s*${key}\\s*\\}`, "g");
+                    const re = new RegExp(`\\$\\{\\s*${key2}\\s*\\}`, "g");
                     content = content.replace(re, String(v));
                   }
                 } else if (typeof args[0] === "string") {
@@ -78269,6 +78234,21 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
     init_worktree_bootstrap_config();
     init_mesh_events();
     init_config();
+    async function decideOssCloneSync(ossCtx, worktreeOssSha, sourceSha, rg) {
+      if (!worktreeOssSha || !sourceSha || worktreeOssSha === sourceSha) return "noop";
+      const isAncestor = async (ancestor, descendant) => {
+        try {
+          await rg(ossCtx, ["merge-base", "--is-ancestor", ancestor, descendant], { timeoutMs: 1e4 });
+          return true;
+        } catch (err) {
+          if (err?.exitCode === 1 || err?.code === 1) return false;
+          throw err;
+        }
+      };
+      if (await isAncestor(sourceSha, worktreeOssSha)) return "skip_rewind";
+      if (await isAncestor(worktreeOssSha, sourceSha)) return "advance";
+      return "skip_diverged";
+    }
     var meshCrudHandlers = {
       list_meshes: async (_ctx, _args) => {
         try {
@@ -78359,7 +78339,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
       // entry. This is an export scaffold for the operator to review and commit to
       // the repo, NOT an automatic data migration: nothing is written to disk and
       // meshes.json is untouched. The returned `scaffold` (object) + `scaffoldJson`
-      // (2-space text) capture the local policy + coordinator prompt override/append.
+      // (2-space text) capture the coordinator prompt override/append (policy is
+      // machine-local and is intentionally NOT exported into mesh.json).
       export_mesh_json_config: async (_ctx, args) => {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         if (!meshId) return { success: false, error: "meshId required" };
@@ -78730,7 +78711,7 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             }
           };
           const initSubmodules = sourceNode.policy?.initSubmodulesOnClone !== false;
-          const loadedBootstrap = loadMeshWorktreeBootstrapConfig(mesh, result.worktreePath);
+          const loadedBootstrap = loadRepoSettings({ workspace: result.worktreePath, mesh }).worktreeBootstrap;
           const runningBootstrapState = {
             status: "running",
             required: loadedBootstrap.config?.required !== false,
@@ -78764,12 +78745,25 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
                       const ossCtx = { workspace: `${result.worktreePath}/oss`, repoRoot: `${result.worktreePath}/oss`, isGitRepo: true };
                       const worktreeOssHeadOut = await rg(ossCtx, ["rev-parse", "HEAD"], { timeoutMs: 1e4 });
                       const worktreeOssSha = (typeof worktreeOssHeadOut === "string" ? worktreeOssHeadOut : worktreeOssHeadOut?.stdout ?? "").trim();
-                      if (worktreeOssSha !== sourceSha) {
+                      if (worktreeOssSha && worktreeOssSha !== sourceSha) {
                         await rg(ossCtx, ["fetch", `${sourceWorkspace}/oss`, "HEAD"], { timeoutMs: 6e4 });
-                        await rg(ossCtx, ["checkout", sourceSha], { timeoutMs: 1e4 });
-                        await rg(worktreeCtx, ["add", "oss"], { timeoutMs: 1e4 });
-                        await rg(worktreeCtx, ["commit", "-m", "chore: sync oss to source node HEAD on clone"], { timeoutMs: 1e4 });
-                        console.log(`[mesh] Synced oss submodule to source HEAD ${sourceSha.slice(0, 8)} in worktree`);
+                        let ossAction;
+                        try {
+                          ossAction = await decideOssCloneSync(ossCtx, worktreeOssSha, sourceSha, rg);
+                        } catch (decideErr) {
+                          ossAction = "skip_diverged";
+                          console.warn(`[mesh] oss submodule sync guard could not resolve ancestry (kept fresh worktree HEAD): ${decideErr?.message ?? decideErr}`);
+                        }
+                        if (ossAction === "advance") {
+                          await rg(ossCtx, ["checkout", sourceSha], { timeoutMs: 1e4 });
+                          await rg(worktreeCtx, ["add", "oss"], { timeoutMs: 1e4 });
+                          await rg(worktreeCtx, ["commit", "-m", "chore: sync oss to source node HEAD on clone"], { timeoutMs: 1e4 });
+                          console.log(`[mesh] Advanced oss submodule to newer source HEAD ${sourceSha.slice(0, 8)} in worktree`);
+                        } else if (ossAction === "skip_rewind") {
+                          console.warn(`[mesh] Skipped oss submodule rewind on clone: source node oss ${sourceSha.slice(0, 8)} is an ancestor of the fresh worktree oss ${worktreeOssSha.slice(0, 8)} \u2014 kept fresher worktree HEAD`);
+                        } else if (ossAction === "skip_diverged") {
+                          console.warn(`[mesh] Skipped oss submodule sync on clone: source node oss ${sourceSha.slice(0, 8)} diverged from the fresh worktree oss ${worktreeOssSha.slice(0, 8)} \u2014 kept worktree HEAD (coordinator reconciles)`);
+                        }
                       }
                     }
                   } catch (ossErr) {
@@ -79199,9 +79193,20 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
             targetNodeId: typeof args?.targetNodeId === "string" ? args.targetNodeId.trim() : void 0,
             targetSessionId: typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : void 0,
             clearTargetNode: args?.clearTargetNode === true,
-            clearTargetSession: args?.clearTargetSession !== false
+            clearTargetSession: args?.clearTargetSession !== false,
+            // CANON-IDENTITY: an in-flight (actively-generating) task is refused by
+            // default to avoid a duplicate second dispatch; an explicit operator
+            // force overrides that guard (and the retry cap).
+            force: args?.force === true
           });
           if (!task) return { success: false, error: `Queue task '${taskId}' not found` };
+          if (task.status === "assigned" && args?.force !== true) {
+            return {
+              success: false,
+              error: `Task '${taskId}' is actively dispatched/generating; requeue refused to avoid a duplicate second dispatch. Pass force:true to override, or cancel and re-enqueue.`,
+              task
+            };
+          }
           return { success: true, task };
         } catch (e) {
           return { success: false, error: e.message };
@@ -80706,15 +80711,15 @@ ${ptyResult.output.slice(-2e3)}`);
     function maskArgs(args) {
       if (!args || typeof args !== "object") return void 0;
       const masked = {};
-      for (const [key, value] of Object.entries(args)) {
-        if (SENSITIVE_KEYS.has(key)) {
-          masked[key] = typeof value === "string" ? `[${value.length} chars]` : "[masked]";
-        } else if (key.startsWith("_")) {
-          masked[key] = value;
+      for (const [key2, value] of Object.entries(args)) {
+        if (SENSITIVE_KEYS.has(key2)) {
+          masked[key2] = typeof value === "string" ? `[${value.length} chars]` : "[masked]";
+        } else if (key2.startsWith("_")) {
+          masked[key2] = value;
         } else if (typeof value === "object" && value !== null) {
-          masked[key] = Array.isArray(value) ? `[Array(${value.length})]` : `[Object]`;
+          masked[key2] = Array.isArray(value) ? `[Array(${value.length})]` : `[Object]`;
         } else {
-          masked[key] = value;
+          masked[key2] = value;
         }
       }
       return masked;
@@ -81803,23 +81808,23 @@ ${ptyResult.output.slice(-2e3)}`);
        * neither gate is satisfied.
        */
       async probe(daemonId, workspace, probe) {
-        const key = this.key(daemonId, workspace);
-        const cached3 = this.recent.get(key);
+        const key2 = this.key(daemonId, workspace);
+        const cached3 = this.recent.get(key2);
         if (cached3 && this.now() - cached3.at < this.reuseMs) {
           return cached3.value;
         }
-        const existing = this.inflight.get(key);
+        const existing = this.inflight.get(key2);
         if (existing) return existing;
         const pending = (async () => {
           const result = await probe();
-          if (result) this.recent.set(key, { at: this.now(), value: result });
+          if (result) this.recent.set(key2, { at: this.now(), value: result });
           return result;
         })();
-        this.inflight.set(key, pending);
+        this.inflight.set(key2, pending);
         try {
           return await pending;
         } finally {
-          if (this.inflight.get(key) === pending) this.inflight.delete(key);
+          if (this.inflight.get(key2) === pending) this.inflight.delete(key2);
         }
       }
     };
@@ -84511,8 +84516,8 @@ ${mergeTreeErr?.stderr || ""}`;
               if (source !== "refine_mesh_node_async_job") continue;
               const jobId = e.payload?.refineJob?.jobId;
               if (!jobId || terminal.has(`${e.nodeId}:${jobId}`)) continue;
-              const key = this.buildRefineJobKey(meshId, e.nodeId);
-              if (this.runningRefineJobs.has(key)) continue;
+              const key2 = this.buildRefineJobKey(meshId, e.nodeId);
+              if (this.runningRefineJobs.has(key2)) continue;
               const coordinatorDaemonId = e.payload?.refineJob?.targetCoordinatorDaemonId;
               LOG2.info("Mesh", `[Refinery] Auto-resuming interrupted refine job for node ${e.nodeId} (jobId=${jobId})`);
               void this.startMeshRefineJob(meshId, e.nodeId, {
@@ -85595,7 +85600,7 @@ ${hintLines.join("\n")}` : "",
         }
       }
       async finishMeshRefineBatchJob(handle, orderedNodes, ordering, args) {
-        const key = this.buildRefineBatchJobKey(handle.meshId);
+        const key2 = this.buildRefineBatchJobKey(handle.meshId);
         let result;
         try {
           result = await this.runMeshRefineBatchConvergence(handle.meshId, orderedNodes, ordering, args);
@@ -85627,8 +85632,8 @@ ${hintLines.join("\n")}` : "",
           coordinatorDaemonId: handle.targetCoordinatorDaemonId
         });
         const terminal = { ...terminalHandle, result: normalizedResult };
-        this.terminalRefineBatchJobs.set(key, terminal);
-        this.runningRefineBatchJobs.delete(key);
+        this.terminalRefineBatchJobs.set(key2, terminal);
+        this.runningRefineBatchJobs.delete(key2);
         this.invalidateAggregateMeshStatus(handle.meshId);
         await this.appendRefineBatchJobLedger(isTerminalSuccess ? "task_completed" : "task_failed", terminalHandle, normalizedResult);
         this.queueRefineBatchJobEvent(isTerminalSuccess ? "refine:completed" : "refine:failed", terminalHandle, normalizedResult);
@@ -85652,8 +85657,8 @@ ${hintLines.join("\n")}` : "",
         if (nodeIds.length === 0) {
           return { ...planRecord, success: true, batch: true, dryRun: false, async: false };
         }
-        const key = this.buildRefineBatchJobKey(meshId);
-        const running = this.runningRefineBatchJobs.get(key);
+        const key2 = this.buildRefineBatchJobKey(meshId);
+        const running = this.runningRefineBatchJobs.get(key2);
         if (running) return { ...running, duplicate: true };
         const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
         const mesh = meshRecord?.mesh;
@@ -85668,7 +85673,7 @@ ${hintLines.join("\n")}` : "",
         };
         const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : this.deps.statusInstanceId || void 0;
         const handle = this.buildRefineBatchJobHandle({ meshId, nodeIds, order, coordinatorDaemonId });
-        this.runningRefineBatchJobs.set(key, handle);
+        this.runningRefineBatchJobs.set(key2, handle);
         await this.appendRefineBatchJobLedger("task_dispatched", handle);
         this.queueRefineBatchJobEvent("refine:accepted", handle);
         setImmediate(() => {
@@ -85683,7 +85688,7 @@ ${hintLines.join("\n")}` : "",
         };
       }
       async finishMeshRefineJob(handle, args) {
-        const key = this.buildRefineJobKey(handle.meshId, handle.targetNodeId);
+        const key2 = this.buildRefineJobKey(handle.meshId, handle.targetNodeId);
         let result;
         try {
           result = await this.executeMeshRefineNodeSynchronously(handle.meshId, handle.targetNodeId, args);
@@ -85751,17 +85756,17 @@ ${hintLines.join("\n")}` : "",
           coordinatorDaemonId: handle.targetCoordinatorDaemonId
         });
         const terminal = { ...terminalHandle, result: normalizedResult };
-        this.terminalRefineJobs.set(key, terminal);
-        this.runningRefineJobs.delete(key);
+        this.terminalRefineJobs.set(key2, terminal);
+        this.runningRefineJobs.delete(key2);
         this.invalidateAggregateMeshStatus(handle.meshId);
         await this.appendRefineJobLedger(isTerminalSuccess ? "task_completed" : "task_failed", terminalHandle, normalizedResult);
         this.queueRefineJobEvent(isTerminalSuccess ? "refine:completed" : "refine:failed", terminalHandle, normalizedResult);
       }
       async startMeshRefineJob(meshId, nodeId, args) {
-        const key = this.buildRefineJobKey(meshId, nodeId);
-        const running = this.runningRefineJobs.get(key);
+        const key2 = this.buildRefineJobKey(meshId, nodeId);
+        const running = this.runningRefineJobs.get(key2);
         if (running) return { ...running, duplicate: true };
-        const terminal = this.terminalRefineJobs.get(key);
+        const terminal = this.terminalRefineJobs.get(key2);
         const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
         const mesh = meshRecord?.mesh;
         const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
@@ -85769,7 +85774,7 @@ ${hintLines.join("\n")}` : "",
         if (!node.isLocalWorktree || !node.workspace) return { success: false, error: `Refinery requires a local worktree node` };
         const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : this.deps.statusInstanceId || void 0;
         const handle = this.buildRefineJobHandle({ meshId, nodeId, node, retryOfJobId: terminal?.jobId, coordinatorDaemonId });
-        this.runningRefineJobs.set(key, handle);
+        this.runningRefineJobs.set(key2, handle);
         await this.appendRefineJobLedger("task_dispatched", handle);
         this.queueRefineJobEvent("refine:accepted", handle);
         setImmediate(() => {
@@ -85825,27 +85830,27 @@ ${hintLines.join("\n")}` : "",
        */
       async stopIde(ideType, killProcess = false) {
         const cdpKeysToRemove = [];
-        for (const key of this.deps.cdpManagers.keys()) {
-          if (key === ideType || key.startsWith(`${ideType}_`)) {
-            cdpKeysToRemove.push(key);
+        for (const key2 of this.deps.cdpManagers.keys()) {
+          if (key2 === ideType || key2.startsWith(`${ideType}_`)) {
+            cdpKeysToRemove.push(key2);
           }
         }
-        for (const key of cdpKeysToRemove) {
-          const cdp = this.deps.cdpManagers.get(key);
+        for (const key2 of cdpKeysToRemove) {
+          const cdp = this.deps.cdpManagers.get(key2);
           if (cdp) {
             try {
               cdp.disconnect();
             } catch {
             }
-            this.deps.cdpManagers.delete(key);
-            this.deps.sessionRegistry.unregisterByManagerKey(key);
-            LOG2.info("StopIDE", `CDP disconnected: ${key}`);
+            this.deps.cdpManagers.delete(key2);
+            this.deps.sessionRegistry.unregisterByManagerKey(key2);
+            LOG2.info("StopIDE", `CDP disconnected: ${key2}`);
           }
         }
         const keysToRemove = [];
-        for (const key of this.deps.instanceManager.listInstanceIds()) {
-          if (key === `ide:${ideType}` || typeof key === "string" && key.startsWith(`ide:${ideType}_`)) {
-            keysToRemove.push(key);
+        for (const key2 of this.deps.instanceManager.listInstanceIds()) {
+          if (key2 === `ide:${ideType}` || typeof key2 === "string" && key2.startsWith(`ide:${ideType}_`)) {
+            keysToRemove.push(key2);
           }
         }
         for (const instanceKey of keysToRemove) {
@@ -90500,9 +90505,9 @@ async (params) => {
           }
           if (Date.now() - lastApprovalTime < 2e3) return;
           if (approvalPatterns.some((p) => p.test(approvalBuffer))) {
-            const key = approvalKeys[1] || approvalKeys[0] || "a\r";
-            writeFn(key);
-            ctx.log(`Auto-Implement auto-approved prompt! Sending: ${JSON.stringify(key)}`);
+            const key2 = approvalKeys[1] || approvalKeys[0] || "a\r";
+            writeFn(key2);
+            ctx.log(`Auto-Implement auto-approved prompt! Sending: ${JSON.stringify(key2)}`);
             sendAutoImplSSE(ctx, { event: "output", data: { chunk: `
 [\u{1F916} ADHDev Auto-Approve] CLI Action Approved
 `, stream: "stdout" } });
@@ -91752,8 +91757,8 @@ data: ${JSON.stringify(msg.data)}
           category: p.category
         }));
         const cdpStatus = {};
-        for (const [key, cdp] of this.cdpManagers.entries()) {
-          cdpStatus[key] = { connected: cdp.isConnected };
+        for (const [key2, cdp] of this.cdpManagers.entries()) {
+          cdpStatus[key2] = { connected: cdp.isConnected };
         }
         this.json(res, 200, {
           devMode: true,
@@ -92073,16 +92078,16 @@ data: ${JSON.stringify(msg.data)}
           errors.push(...validation.errors);
           warnings.push(...validation.warnings);
           if (config2.settings) {
-            for (const [key, val] of Object.entries(config2.settings)) {
+            for (const [key2, val] of Object.entries(config2.settings)) {
               const s2 = val;
-              if (!s2.type) errors.push(`settings.${key}: missing type`);
+              if (!s2.type) errors.push(`settings.${key2}: missing type`);
               else if (!["boolean", "number", "string", "select"].includes(s2.type))
-                errors.push(`settings.${key}: invalid type '${s2.type}'`);
-              if (s2.default === void 0) warnings.push(`settings.${key}: no default value`);
+                errors.push(`settings.${key2}: invalid type '${s2.type}'`);
+              if (s2.default === void 0) warnings.push(`settings.${key2}: no default value`);
               if (s2.type === "number" && s2.min !== void 0 && s2.max !== void 0 && s2.min > s2.max)
-                errors.push(`settings.${key}: min (${s2.min}) > max (${s2.max})`);
+                errors.push(`settings.${key2}: min (${s2.min}) > max (${s2.max})`);
               if (s2.type === "select" && (!s2.options || !Array.isArray(s2.options) || s2.options.length === 0))
-                errors.push(`settings.${key}: select type requires options[]`);
+                errors.push(`settings.${key2}: select type requires options[]`);
             }
           }
           if (config2.cdpPorts && Array.isArray(config2.cdpPorts)) {
@@ -92860,21 +92865,21 @@ data: ${JSON.stringify(msg.data)}
     function encodeControlLetter(letter) {
       return String.fromCharCode(letter.charCodeAt(0) - 96);
     }
-    function encodeShiftedKey(key) {
-      if (isLowercaseLetter(key)) return key.toUpperCase();
-      if (key.startsWith("ctrl+") && isLowercaseLetter(key.slice(5))) {
-        return encodeControlLetter(key.slice(5));
+    function encodeShiftedKey(key2) {
+      if (isLowercaseLetter(key2)) return key2.toUpperCase();
+      if (key2.startsWith("ctrl+") && isLowercaseLetter(key2.slice(5))) {
+        return encodeControlLetter(key2.slice(5));
       }
-      if (key.startsWith("alt+") && isLowercaseLetter(key.slice(4))) {
-        return `\x1B${key.slice(4).toUpperCase()}`;
+      if (key2.startsWith("alt+") && isLowercaseLetter(key2.slice(4))) {
+        return `\x1B${key2.slice(4).toUpperCase()}`;
       }
-      if (key === "tab") return "\x1B[Z";
-      if (key in SHIFTED_CSI_KEYS) return SHIFTED_CSI_KEYS[key];
-      if (key in BASE_KEY_SEQUENCES) return BASE_KEY_SEQUENCES[key];
-      throw new Error(`Unsupported named key: shift+${key}`);
+      if (key2 === "tab") return "\x1B[Z";
+      if (key2 in SHIFTED_CSI_KEYS) return SHIFTED_CSI_KEYS[key2];
+      if (key2 in BASE_KEY_SEQUENCES) return BASE_KEY_SEQUENCES[key2];
+      throw new Error(`Unsupported named key: shift+${key2}`);
     }
-    function namedKeyToAnsi(key) {
-      const normalized = String(key || "").trim().toLowerCase();
+    function namedKeyToAnsi(key2) {
+      const normalized = String(key2 || "").trim().toLowerCase();
       if (normalized in BASE_KEY_SEQUENCES) return BASE_KEY_SEQUENCES[normalized];
       if (normalized.startsWith("ctrl+") && isLowercaseLetter(normalized.slice(5))) {
         return encodeControlLetter(normalized.slice(5));
@@ -92883,7 +92888,7 @@ data: ${JSON.stringify(msg.data)}
         return `\x1B${normalized.slice(4)}`;
       }
       if (normalized.startsWith("shift+")) return encodeShiftedKey(normalized.slice(6));
-      throw new Error(`Unsupported named key: ${key}`);
+      throw new Error(`Unsupported named key: ${key2}`);
     }
     function namedKeysToAnsi(keys) {
       if (!Array.isArray(keys)) throw new Error("keys must be an array");
@@ -93349,19 +93354,19 @@ data: ${JSON.stringify(msg.data)}
         if (!ids) return [];
         return [...ids].map((id) => this.bySessionId.get(id)).filter(Boolean);
       }
-      addIndex(index, key, sessionId) {
-        let set2 = index.get(key);
+      addIndex(index, key2, sessionId) {
+        let set2 = index.get(key2);
         if (!set2) {
           set2 = /* @__PURE__ */ new Set();
-          index.set(key, set2);
+          index.set(key2, set2);
         }
         set2.add(sessionId);
       }
-      removeIndex(index, key, sessionId) {
-        const set2 = index.get(key);
+      removeIndex(index, key2, sessionId) {
+        const set2 = index.get(key2);
         if (!set2) return;
         set2.delete(sessionId);
-        if (set2.size === 0) index.delete(key);
+        if (set2.size === 0) index.delete(key2);
       }
     };
     init_logger();