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

package/dist/index.mjs

@@ -17,9 +17,9 @@ var __export = (target, all) => {
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
   }
   return to;
 };
@@ -31,14 +31,6 @@ function normalizeMeshSchedulingStrategy(value) {
   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;
@@ -125,7 +117,7 @@ function resolveProviderMaxParallel(nodePolicy, providerType) {
   }
   return void 0;
 }
-var MESH_SCHEDULING_STRATEGIES, DEFAULT_MESH_SCHEDULING_STRATEGY, MESH_DISTRIBUTIONS, DEFAULT_MESH_DISTRIBUTION, MESH_CONVERGE_REFINE_TAG, MESH_CONVERGE_FAST_FORWARD_TAG, DEFAULT_MESH_POLICY, SESSION_CLEANUP_MODES, SPAWNED_SESSION_VISIBILITY_MODES, DIRTY_WORKSPACE_BEHAVIORS, MESH_MAX_PARALLEL_TASKS_MIN, MESH_MAX_PARALLEL_TASKS_MAX, DEFAULT_MESH_READONLY_MULTIPLIER;
+var MESH_SCHEDULING_STRATEGIES, DEFAULT_MESH_SCHEDULING_STRATEGY, MESH_CONVERGE_REFINE_TAG, MESH_CONVERGE_FAST_FORWARD_TAG, DEFAULT_MESH_POLICY, SESSION_CLEANUP_MODES, SPAWNED_SESSION_VISIBILITY_MODES, DIRTY_WORKSPACE_BEHAVIORS, MESH_MAX_PARALLEL_TASKS_MIN, MESH_MAX_PARALLEL_TASKS_MAX, DEFAULT_MESH_READONLY_MULTIPLIER;
 var init_repo_mesh_types = __esm({
   "src/repo-mesh-types.ts"() {
     "use strict";
@@ -136,8 +128,6 @@ var init_repo_mesh_types = __esm({
       "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 = {
@@ -394,10 +384,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "69cd9c459ec9efafe19a05f66899bb791d6e0561" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "69cd9c45" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = 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:20.391Z" : void 0);
+  const commit = readInjected(true ? "7a774e95a82354f5357197b3c84f63e68b5f7a5d" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "7a774e95" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.413" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-28T11:48:26.300Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -418,18 +408,18 @@ function isRecord(value) {
 function isStringArray(value) {
   return Array.isArray(value) && value.every((v) => typeof v === "string" && v.length > 0);
 }
-function validateTarget(value, key, errors) {
+function validateTarget(value, key2, errors) {
   if (!isRecord(value)) {
-    errors.push(`impactTargets.${key} must be an object`);
+    errors.push(`impactTargets.${key2} must be an object`);
     return void 0;
   }
   const { recommendedCommand } = value;
   if (typeof recommendedCommand !== "string" || !recommendedCommand.length) {
-    errors.push(`impactTargets.${key}.recommendedCommand must be a non-empty string`);
+    errors.push(`impactTargets.${key2}.recommendedCommand must be a non-empty string`);
     return void 0;
   }
   for (const k of Object.keys(value)) {
-    if (k !== "recommendedCommand") errors.push(`impactTargets.${key}.${k} is not a recognized field (only recommendedCommand)`);
+    if (k !== "recommendedCommand") errors.push(`impactTargets.${key2}.${k} is not a recognized field (only recommendedCommand)`);
   }
   return { recommendedCommand };
 }
@@ -456,20 +446,20 @@ function validateChangeImpactConfig(raw, source = "inline") {
       errors.push("impactTargets must be an object");
     } else {
       const targets = {};
-      for (const key of Object.keys(raw.impactTargets)) {
-        if (key !== "daemon" && key !== "web" && key !== "none") {
-          errors.push(`impactTargets.${key} is not a recognized impact kind (daemon|web|none)`);
+      for (const key2 of Object.keys(raw.impactTargets)) {
+        if (key2 !== "daemon" && key2 !== "web" && key2 !== "none") {
+          errors.push(`impactTargets.${key2} is not a recognized impact kind (daemon|web|none)`);
           continue;
         }
-        const target = validateTarget(raw.impactTargets[key], key, errors);
-        if (target) targets[key] = target;
+        const target = validateTarget(raw.impactTargets[key2], key2, errors);
+        if (target) targets[key2] = target;
       }
       if (Object.keys(targets).length) config.impactTargets = targets;
     }
   }
-  for (const key of Object.keys(raw)) {
-    if (!["daemonRuntimePackages", "webOnlyPackages", "nonRuntimeRootFilePatterns", "impactTargets"].includes(key)) {
-      errors.push(`unknown config key '${key}'`);
+  for (const key2 of Object.keys(raw)) {
+    if (!["daemonRuntimePackages", "webOnlyPackages", "nonRuntimeRootFilePatterns", "impactTargets"].includes(key2)) {
+      errors.push(`unknown config key '${key2}'`);
     }
   }
   return { valid: errors.length === 0, errors, config: errors.length === 0 ? config : void 0 };
@@ -798,12 +788,12 @@ function resolveChangeImpactConfigForRepo(repoRoot, options) {
     return { config: null, sourceKey: "forced-default" };
   }
   if (options.changeImpactConfig !== void 0) {
-    let key = "injected";
+    let key2 = "injected";
     try {
-      key = `injected:${JSON.stringify(options.changeImpactConfig)}`;
+      key2 = `injected:${JSON.stringify(options.changeImpactConfig)}`;
     } catch {
     }
-    return { config: options.changeImpactConfig, sourceKey: key };
+    return { config: options.changeImpactConfig, sourceKey: key2 };
   }
   if (!repoRoot) {
     return { config: null, sourceKey: "no-repo-root" };
@@ -2365,9 +2355,9 @@ function dismissSessionNotification(state, sessionId, notificationId, providerSe
   ].filter(Boolean)));
   const nextSessionNotificationDismissals = { ...state.sessionNotificationDismissals || {} };
   const nextSessionNotificationUnreadOverrides = { ...state.sessionNotificationUnreadOverrides || {} };
-  for (const key of dismissalKeys) {
-    nextSessionNotificationDismissals[key] = dismissalId;
-    delete nextSessionNotificationUnreadOverrides[key];
+  for (const key2 of dismissalKeys) {
+    nextSessionNotificationDismissals[key2] = dismissalId;
+    delete nextSessionNotificationUnreadOverrides[key2];
   }
   return {
     ...state,
@@ -2384,9 +2374,9 @@ function markSessionNotificationUnread(state, sessionId, notificationId, provide
   ].filter(Boolean)));
   const nextSessionNotificationDismissals = { ...state.sessionNotificationDismissals || {} };
   const nextSessionNotificationUnreadOverrides = { ...state.sessionNotificationUnreadOverrides || {} };
-  for (const key of unreadKeys) {
-    nextSessionNotificationUnreadOverrides[key] = unreadId;
-    delete nextSessionNotificationDismissals[key];
+  for (const key2 of unreadKeys) {
+    nextSessionNotificationUnreadOverrides[key2] = unreadId;
+    delete nextSessionNotificationDismissals[key2];
   }
   return {
     ...state,
@@ -2450,11 +2440,11 @@ function markSessionSeen(state, sessionId, seenAt = Date.now(), completionMarker
   const nextSessionReadMarkers = { ...prevMarkers };
   const nextSessionNotificationDismissals = { ...state.sessionNotificationDismissals || {} };
   const nextSessionNotificationUnreadOverrides = { ...state.sessionNotificationUnreadOverrides || {} };
-  for (const key of readKeys) {
-    nextSessionReads[key] = Math.max(prev[key] || 0, seenAt);
-    if (nextMarker) nextSessionReadMarkers[key] = nextMarker;
-    delete nextSessionNotificationDismissals[key];
-    delete nextSessionNotificationUnreadOverrides[key];
+  for (const key2 of readKeys) {
+    nextSessionReads[key2] = Math.max(prev[key2] || 0, seenAt);
+    if (nextMarker) nextSessionReadMarkers[key2] = nextMarker;
+    delete nextSessionNotificationDismissals[key2];
+    delete nextSessionNotificationUnreadOverrides[key2];
   }
   return {
     ...state,
@@ -3157,6 +3147,12 @@ function machineCoreFromDaemonId(id) {
   }
   return trimmed;
 }
+function canonicalDaemonId(id) {
+  const core = machineCoreFromDaemonId(id);
+  if (!core) return void 0;
+  if (!core.startsWith("mach_")) return core;
+  return `daemon_${core}`;
+}
 function daemonIdsEquivalent(a, b) {
   const coreA = machineCoreFromDaemonId(a);
   const coreB = machineCoreFromDaemonId(b);
@@ -3321,8 +3317,8 @@ function expandPromptPlaceholders(template, ctx) {
     rules: buildRulesSection(coordinatorCliType),
     toolExposurePreflight: TOOL_EXPOSURE_PREFLIGHT_SECTION
   };
-  return template.replace(/\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g, (m, key) => {
-    return Object.prototype.hasOwnProperty.call(replacements, key) ? replacements[key] : m;
+  return template.replace(/\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g, (m, key2) => {
+    return Object.prototype.hasOwnProperty.call(replacements, key2) ? replacements[key2] : m;
   });
 }
 function buildNodeStatusSection(nodes) {
@@ -4721,6 +4717,33 @@ var init_mesh_delivery_policy = __esm({
   }
 });
 
+// src/mesh/mesh-task-inflight.ts
+function key(meshId, taskId) {
+  return `${meshId}::${taskId}`;
+}
+function beginTaskDispatchInFlight(meshId, taskId) {
+  if (!meshId || !taskId) return false;
+  const k = key(meshId, taskId);
+  if (inFlight.has(k)) return false;
+  inFlight.add(k);
+  return true;
+}
+function isTaskDispatchInFlight(meshId, taskId) {
+  if (!meshId || !taskId) return false;
+  return inFlight.has(key(meshId, taskId));
+}
+function endTaskDispatchInFlight(meshId, taskId) {
+  if (!meshId || !taskId) return;
+  inFlight.delete(key(meshId, taskId));
+}
+var inFlight;
+var init_mesh_task_inflight = __esm({
+  "src/mesh/mesh-task-inflight.ts"() {
+    "use strict";
+    inFlight = /* @__PURE__ */ new Set();
+  }
+});
+
 // src/mesh/mesh-work-queue.ts
 var mesh_work_queue_exports = {};
 __export(mesh_work_queue_exports, {
@@ -4988,14 +5011,14 @@ function firstProviderPriority(policy) {
   if (!Array.isArray(raw)) return void 0;
   return raw.find((type) => typeof type === "string" && type.trim())?.trim();
 }
-function readNodeOverride(node, key) {
+function readNodeOverride(node, key2) {
   const overrides = node?.userOverrides;
   if (!overrides || typeof overrides !== "object" || Array.isArray(overrides)) return null;
-  const value = overrides[key];
+  const value = overrides[key2];
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
-function readNodeReporter(node, key) {
-  const value = key === "platform" ? node?.reportedPlatform : node?.reportedArch;
+function readNodeReporter(node, key2) {
+  const value = key2 === "platform" ? node?.reportedPlatform : node?.reportedArch;
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 function buildMeshNodeCapabilityTags(node, providerType) {
@@ -5214,6 +5237,7 @@ function updateTaskStatus(meshId, taskId, status, opts) {
     if (!entry) return null;
     entry.status = status;
     MeshRuntimeStore.getInstance().updateQueueEntry(entry);
+    if (status !== "assigned") endTaskDispatchInFlight(meshId, taskId);
     if (DEPENDENCY_FAILURE_TERMINALS.has(status)) propagateDependencyFailure(meshId, taskId);
     return entry;
   });
@@ -5238,6 +5262,7 @@ function cancelTask(meshId, taskId, opts) {
     entry.cancelledAt = now;
     if (opts?.reason) entry.cancelReason = opts.reason;
     MeshRuntimeStore.getInstance().updateQueueEntry(entry);
+    endTaskDispatchInFlight(meshId, taskId);
     propagateDependencyFailure(meshId, taskId);
     return entry;
   });
@@ -5247,6 +5272,11 @@ function requeueTask(meshId, taskId, opts) {
   return withQueueLock(meshId, () => {
     const entry = MeshRuntimeStore.getInstance().findQueueEntryById(meshId, taskId);
     if (!entry) return null;
+    if (!opts?.force && isTaskDispatchInFlight(meshId, taskId)) {
+      LOG.warn("MeshQueue", `Refusing to requeue task ${taskId} on mesh ${meshId}: it is actively dispatched/generating (single-flight in-flight). Requeueing now would open a duplicate second dispatch into another session. Pass force to override.`);
+      return entry;
+    }
+    endTaskDispatchInFlight(meshId, taskId);
     const currentCount = entry.requeueCount || 0;
     const maxRetries = opts?.maxRetries ?? entry.maxRetries ?? 1;
     if (!opts?.force && currentCount >= maxRetries) {
@@ -5291,6 +5321,7 @@ function reclaimStrandedAssignedTask(meshId, taskId, opts) {
     delete entry.dispatchTimestamp;
     entry.strandedReclaimCount = reclaims;
     entry.updatedAt = now;
+    endTaskDispatchInFlight(meshId, taskId);
     if (reclaims > MAX_STRANDED_RECLAIMS) {
       entry.status = "failed";
       entry.cancelReason = `stranded_dispatch_unrecovered: reclaimed ${reclaims - 1} time(s) without a confirmed dispatch`;
@@ -5334,6 +5365,7 @@ function updateSessionTaskStatus(meshId, sessionId, status, opts) {
     }
     entry.status = status;
     store.updateQueueEntry(entry);
+    if (status !== "assigned") endTaskDispatchInFlight(meshId, entry.id);
     if (DEPENDENCY_FAILURE_TERMINALS.has(status)) propagateDependencyFailure(meshId, entry.id);
     return entry;
   });
@@ -5447,6 +5479,7 @@ var init_mesh_work_queue = __esm({
     init_logger();
     init_mesh_ledger();
     init_mesh_delivery_policy();
+    init_mesh_task_inflight();
     ACTIVE_MESH_QUEUE_STATUSES = ["pending", "assigned"];
     HISTORICAL_MESH_QUEUE_STATUSES = ["completed", "failed", "cancelled"];
     MESH_TASK_MODES = ["code_change", "validation", "live_debug_readonly", "launch_app", "convergence"];
@@ -7092,6 +7125,9 @@ __export(mesh_missions_exports, {
   upsertMeshMission: () => upsertMeshMission
 });
 import { randomUUID as randomUUID7 } from "crypto";
+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";
 }
@@ -7104,6 +7140,8 @@ function upsertMeshMission(meshId, input) {
   const id = typeof input.id === "string" && input.id.trim() ? input.id.trim() : randomUUID7();
   const store = MeshRuntimeStore.getInstance();
   const existing = store.getMission(meshId, id);
+  const prevStatus = existing ? normalizeMissionStatus(existing.status) : null;
+  const prevGoal = existing?.goal ?? "";
   const record = {
     id,
     meshId,
@@ -7113,7 +7151,61 @@ function upsertMeshMission(meshId, input) {
   };
   store.upsertMission(record);
   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, prevStatus, prevGoal } = args;
+  try {
+    if (isCreate) {
+      const goal = record.goal ?? "";
+      appendLedgerEntry(meshId, {
+        kind: "mission_created",
+        payload: {
+          missionId: record.id,
+          title: record.title,
+          goalSummary: summarizeGoalForLedger(goal),
+          goalLength: goal.length,
+          goalTruncated: goal.length > LEDGER_GOAL_SUMMARY_MAX,
+          status: record.status
+        }
+      });
+      return;
+    }
+    if (prevStatus !== null && prevStatus !== record.status) {
+      appendLedgerEntry(meshId, {
+        kind: "mission_status_changed",
+        payload: {
+          missionId: record.id,
+          title: record.title,
+          fromStatus: prevStatus,
+          toStatus: record.status
+        }
+      });
+    }
+    const nextGoal = record.goal ?? "";
+    if (nextGoal !== prevGoal) {
+      appendLedgerEntry(meshId, {
+        kind: "mission_goal_updated",
+        payload: {
+          missionId: record.id,
+          title: record.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) }));
@@ -7217,13 +7309,15 @@ function buildMissionPromptSection(meshId) {
   );
   return lines.join("\n");
 }
-var MESH_MISSION_STATUSES, GOAL_PREVIEW_MAX, COMPACT_STATUS_GOAL_PREVIEW_MAX;
+var LEDGER_GOAL_SUMMARY_MAX, MESH_MISSION_STATUSES, GOAL_PREVIEW_MAX, COMPACT_STATUS_GOAL_PREVIEW_MAX;
 var init_mesh_missions = __esm({
   "src/mesh/mesh-missions.ts"() {
     "use strict";
     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;
@@ -7451,7 +7545,7 @@ function resolveNodeEvidence(nodeId, ledgerEntries) {
           timestamp: entry.timestamp,
           ...entry.sessionId ? { sessionId: entry.sessionId } : {},
           bootstrap: readRecord3(validationSummary?.bootstrap),
-          validation: validationSummary ? Object.fromEntries(Object.entries(validationSummary).filter(([key]) => key !== "bootstrap")) : null,
+          validation: validationSummary ? Object.fromEntries(Object.entries(validationSummary).filter(([key2]) => key2 !== "bootstrap")) : null,
           checkpoint: readRecord3(result?.checkpoint),
           worker: null,
           ...readRecord3(payload.finalBranchConvergenceState) ?? readRecord3(result?.finalBranchConvergenceState) ? { finalBranchConvergenceState: readRecord3(payload.finalBranchConvergenceState) ?? readRecord3(result?.finalBranchConvergenceState) } : {},
@@ -7720,7 +7814,7 @@ function resolveMeshCoordinatorSetup(options) {
   };
 }
 function renderMeshCoordinatorTemplate(template, values) {
-  return template.replace(/\{\{\s*(meshId|workspace|serverName|adhdevMcpCommand|adhdevMcpArgs)\s*\}\}/g, (_, key) => values[key] || "");
+  return template.replace(/\{\{\s*(meshId|workspace|serverName|adhdevMcpCommand|adhdevMcpArgs)\s*\}\}/g, (_, key2) => values[key2] || "");
 }
 function replaceLegacyCliCommandMcpArgs(command, args) {
   return command.replace(
@@ -7729,9 +7823,9 @@ function replaceLegacyCliCommandMcpArgs(command, args) {
   );
 }
 function resolveHermesCoordinatorHome(meshId, workspace) {
-  const key = `${meshId || "mesh"}
+  const key2 = `${meshId || "mesh"}
 ${resolve7(workspace || os4.tmpdir())}`;
-  const hash = shortHash(key);
+  const hash = shortHash(key2);
   return join10(os4.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
 }
 function resolveMcpConfigPath(configPath, workspace) {
@@ -8201,9 +8295,9 @@ function suggestMeshRefineConfig(mesh, workspace) {
   const seen = /* @__PURE__ */ new Set();
   const suggestions = [];
   for (const entry of [...collectProjectContextSuggestions(mesh), ...collectPackageScriptSuggestions(workspace)]) {
-    const key = `${entry.command} ${(entry.args || []).join(" ")}`.trim();
-    if (seen.has(key)) continue;
-    seen.add(key);
+    const key2 = `${entry.command} ${(entry.args || []).join(" ")}`.trim();
+    if (seen.has(key2)) continue;
+    seen.add(key2);
     suggestions.push(entry);
   }
   return {
@@ -8677,6 +8771,216 @@ var init_worktree_bootstrap_config = __esm({
   }
 });
 
+// src/config/mesh-json-config.ts
+var mesh_json_config_exports = {};
+__export(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
+});
+import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
+import { join as join15 } from "path";
+import * as yaml4 from "js-yaml";
+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 config = { 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);
+      config.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) config.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) config.limits = limits;
+    } else {
+      errors.push("limits must be an object when provided");
+    }
+  }
+  return { valid: true, config, 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 = join15(base, relative5);
+      if (!existsSync14(configPath)) continue;
+      try {
+        const parsed = parseConfigText4(configPath, readFileSync11(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 (error) {
+        return { source: relative5, sourceType: "invalid", path: configPath, error: error?.message || String(error) };
+      }
+    }
+  }
+  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(config) {
+  return JSON.stringify(config, null, 2);
+}
+var MESH_JSON_CONFIG_LOCATIONS, MESH_JSON_CONFIG_SCHEMA;
+var init_mesh_json_config = __esm({
+  "src/config/mesh-json-config.ts"() {
+    "use strict";
+    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 }
+          }
+        }
+      }
+    };
+  }
+});
+
 // src/mesh/mesh-fast-forward.ts
 async function fastForwardMeshNode(args) {
   const workspace = typeof args.workspace === "string" ? args.workspace.trim() : "";
@@ -10082,8 +10386,8 @@ var init_mesh_events_utils = __esm({
 });
 
 // src/mesh/mesh-events-pending.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync14, readFileSync as readFileSync11, renameSync as renameSync4, statSync as statSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
-import { join as join15 } from "path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync15, readFileSync as readFileSync12, renameSync as renameSync4, statSync as statSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync6 } from "fs";
+import { join as join16 } from "path";
 import { randomUUID as randomUUID8 } from "crypto";
 function normalizeCoordinatorDaemonIds(coordinatorDaemonId) {
   return expandDaemonIdForms(coordinatorDaemonId);
@@ -10147,9 +10451,9 @@ function getPendingEventsPath(meshId, coordinatorDaemonId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
   if (coordinatorDaemonId) {
     const safeDaemon = coordinatorDaemonId.replace(/[^a-zA-Z0-9_-]/g, "_");
-    return join15(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
+    return join16(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
   }
-  return join15(getLedgerDir(), `${safe}.pending-events.jsonl`);
+  return join16(getLedgerDir(), `${safe}.pending-events.jsonl`);
 }
 function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
   if (!meshId) return [];
@@ -10158,9 +10462,9 @@ function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
   const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   const events = [];
   for (const path43 of paths) {
-    if (!existsSync14(path43)) continue;
+    if (!existsSync15(path43)) continue;
     try {
-      const raw = readFileSync11(path43, "utf-8");
+      const raw = readFileSync12(path43, "utf-8");
       const parsed = raw.split("\n").filter(Boolean).flatMap((line) => {
         try {
           return [JSON.parse(line)];
@@ -10235,9 +10539,9 @@ function reconcilePendingMeshCoordinatorEvents(meshId, events) {
 }
 function trimPendingEventsIfNeeded(path43) {
   try {
-    if (!existsSync14(path43)) return;
+    if (!existsSync15(path43)) return;
     if (statSync6(path43).size <= MAX_PENDING_EVENTS_BYTES) return;
-    const lines = readFileSync11(path43, "utf-8").split("\n").filter(Boolean);
+    const lines = readFileSync12(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) {
@@ -10321,7 +10625,7 @@ function atomicDrainFile(path43) {
     return null;
   }
   try {
-    const content = readFileSync11(tmpPath, "utf-8");
+    const content = readFileSync12(tmpPath, "utf-8");
     try {
       unlinkSync2(tmpPath);
     } catch {
@@ -10344,7 +10648,7 @@ function selectiveDrainFile(path43, predicate) {
   }
   let content;
   try {
-    content = readFileSync11(tmpPath, "utf-8");
+    content = readFileSync12(tmpPath, "utf-8");
   } catch {
     try {
       unlinkSync2(tmpPath);
@@ -10375,7 +10679,7 @@ function selectiveDrainFile(path43, predicate) {
     unlinkSync2(tmpPath);
   } catch {
     try {
-      if (existsSync14(tmpPath) && !existsSync14(path43)) renameSync4(tmpPath, path43);
+      if (existsSync15(tmpPath) && !existsSync15(path43)) renameSync4(tmpPath, path43);
     } catch {
     }
     return [];
@@ -10470,7 +10774,7 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   }
   const paths = coordinatorDaemonId ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   for (const path43 of paths) {
-    if (existsSync14(path43)) try {
+    if (existsSync15(path43)) try {
       unlinkSync2(path43);
     } catch {
     }
@@ -11233,7 +11537,7 @@ var init_provider_cli_shared = __esm({
 import { exec } from "child_process";
 import * as os6 from "os";
 import * as path12 from "path";
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 function parseVersion(raw) {
   const match = raw.match(/v?(\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?)/);
   return match ? match[1] : raw.split("\n")[0].slice(0, 100);
@@ -11257,7 +11561,7 @@ function resolveCommandPath(command) {
   if (isExplicitCommandPath(trimmed)) {
     const expanded = expandHome(trimmed);
     const candidate = path12.isAbsolute(expanded) ? expanded : path12.resolve(expanded);
-    return existsSync15(candidate) ? candidate : null;
+    return existsSync16(candidate) ? candidate : null;
   }
   return null;
 }
@@ -11267,7 +11571,7 @@ async function resolveDetectionPath(command, whichCmd) {
   const whichResult = await execAsync(`${whichCmd} ${shellQuote(command)}`);
   if (whichResult) return whichResult.split("\n")[0];
   const resolved = findBinary(command);
-  if (path12.isAbsolute(resolved) && existsSync15(resolved)) return resolved;
+  if (path12.isAbsolute(resolved) && existsSync16(resolved)) return resolved;
   return null;
 }
 function execAsync(cmd, timeoutMs = 5e3) {
@@ -11485,347 +11789,11 @@ var init_mesh_warmup_deadline = __esm({
   }
 });
 
-// src/config/mesh-json-config.ts
-var mesh_json_config_exports = {};
-__export(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
-});
-import { existsSync as existsSync16, readFileSync as readFileSync12, statSync as statSync7 } from "fs";
-import { join as join18 } from "path";
-import * as yaml4 from "js-yaml";
-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 config = { version: 1 };
-  if (parsed.policy !== void 0) {
-    if (isRecord3(parsed.policy)) {
-      config.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);
-      config.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) config.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) config.limits = limits;
-    } else {
-      errors.push("limits must be an object when provided");
-    }
-  }
-  return { valid: true, config, 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 = join18(base, relative5);
-      if (!existsSync16(configPath)) continue;
-      try {
-        const parsed = parseConfigText4(configPath, readFileSync12(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 (error) {
-        return { source: relative5, sourceType: "invalid", path: configPath, error: error?.message || String(error) };
-      }
-    }
-  }
-  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 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(config) {
-  return JSON.stringify(config, null, 2);
-}
-function validateMeshJsonConfig(raw, source = "inline") {
-  const errors = [];
-  if (!isRecord3(raw)) {
-    return { valid: false, errors: [`${source}: config must be an object`] };
-  }
-  const config = {};
-  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) config.scheduling = scheduling;
-    }
-  }
-  return { valid: errors.length === 0, errors, config: errors.length === 0 ? config : 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 = join18(repoRoot, relative5);
-    if (!existsSync16(configPath)) continue;
-    let mtimeMs = 0;
-    try {
-      mtimeMs = statSync7(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 = readFileSync12(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 (error) {
-      result = { source: relative5, sourceType: "invalid", path: configPath, error: error?.message || String(error), 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 MESH_JSON_CONFIG_LOCATIONS, MESH_JSON_CONFIG_SCHEMA, cache;
-var init_mesh_json_config = __esm({
-  "src/config/mesh-json-config.ts"() {
-    "use strict";
-    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();
-  }
-});
-
 // src/mesh/mesh-queue-assignment.ts
 import { existsSync as existsSync17 } from "fs";
+function localCoordinatorDaemonId() {
+  return canonicalDaemonId(readNonEmptyString2(loadConfig().machineId));
+}
 function __resetIdleAutoFastForwardForTests() {
   idleAutoFastForwardLastAttempt.clear();
 }
@@ -11911,6 +11879,7 @@ function deliverTaskToSession(dispatchThunk, ctx, warmup) {
     if (timer) clearTimeout(timer);
     LOG.error("MeshQueue", `Failed to dispatch task via ${ctx.transport} to node ${ctx.nodeId}: ${e?.message}`);
     updateSessionDeliveryStatus(delivery.id, "failed", { lastError: e?.message, incrementAttempt: true });
+    endTaskDispatchInFlight(ctx.meshId, ctx.task.id);
     updateTaskStatus(ctx.meshId, ctx.task.id, "pending");
     try {
       appendLedgerEntry(ctx.meshId, {
@@ -11984,10 +11953,11 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
     return false;
   }
   LOG.info("MeshQueue", `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
+  beginTaskDispatchInFlight(meshId, task.id);
   if (node?.daemonId && components.dispatchMeshCommand) {
     const isLocalNode = components.cliManager.adapters.has(sessionId);
     if (!isLocalNode) {
-      const localDaemonIdForDispatch = readNonEmptyString2(loadConfig().machineId) || void 0;
+      const localDaemonIdForDispatch = localCoordinatorDaemonId();
       const sourceCoordinatorSessionId = readNonEmptyString2(task.sourceCoordinatorSessionId) || void 0;
       const dispatchMeshCommand = components.dispatchMeshCommand;
       const remoteDaemonId = node.daemonId;
@@ -12026,7 +11996,7 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
   try {
     const inst = components.instanceManager.getInstance(sessionId);
     if (inst && typeof inst.updateSettings === "function") {
-      const localDaemonId = readNonEmptyString2(loadConfig().machineId);
+      const localDaemonId = localCoordinatorDaemonId();
       const localSourceCoordinatorSessionId = readNonEmptyString2(task.sourceCoordinatorSessionId);
       inst.updateSettings({
         meshNodeFor: meshId,
@@ -12051,7 +12021,7 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
         meshId,
         nodeId,
         taskId: task.id,
-        ...readNonEmptyString2(loadConfig().machineId) ? { coordinatorDaemonId: readNonEmptyString2(loadConfig().machineId) } : {},
+        ...localCoordinatorDaemonId() ? { coordinatorDaemonId: localCoordinatorDaemonId() } : {},
         ...readNonEmptyString2(task.sourceCoordinatorSessionId) ? { coordinatorSessionId: readNonEmptyString2(task.sourceCoordinatorSessionId) } : {}
       }
     }),
@@ -12063,7 +12033,7 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
       task,
       transport: "local",
       ...readNonEmptyString2(task.sourceCoordinatorSessionId) ? { sourceCoordinatorSessionId: readNonEmptyString2(task.sourceCoordinatorSessionId) } : {},
-      ...readNonEmptyString2(loadConfig().machineId) ? { sourceCoordinatorDaemonId: readNonEmptyString2(loadConfig().machineId) } : {}
+      ...localCoordinatorDaemonId() ? { sourceCoordinatorDaemonId: localCoordinatorDaemonId() } : {}
     }
   );
   return true;
@@ -12145,8 +12115,8 @@ function notifyCoordinatorOfActionableSkip(meshId, taskId, reason, nodeId) {
 }
 function sweepExpiredCooldowns() {
   const now = Date.now();
-  for (const [key, until] of autoLaunchCooldownUntil) {
-    if (now >= until) autoLaunchCooldownUntil.delete(key);
+  for (const [key2, until] of autoLaunchCooldownUntil) {
+    if (now >= until) autoLaunchCooldownUntil.delete(key2);
   }
 }
 function normalizeProviderPriority(policy) {
@@ -12192,7 +12162,7 @@ function nodeHasActiveMeshWork(components, meshId, nodeId, currentSessionId) {
     const settings = state.settings || {};
     if (readNonEmptyString2(settings.meshNodeFor) !== meshId) return false;
     const instNodeId = readNonEmptyString2(settings.meshNodeId) || readNonEmptyString2(settings.nodeId);
-    if (instNodeId !== nodeId) return false;
+    if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
     const sessionId = readNonEmptyString2(state.instanceId);
     if (currentSessionId && sessionId === currentSessionId && isIdleSessionState(state)) return false;
     return sessionStateLooksActive(state);
@@ -12224,7 +12194,7 @@ function resolveAutoLaunchTarget(components, node) {
   const daemonId = readNonEmptyString2(node?.daemonId);
   if (!daemonId) return { mode: "skip", reason: "remote_auto_launch_unsupported" };
   if (!components.dispatchMeshCommand) return { mode: "skip", reason: "remote_auto_launch_unsupported" };
-  const coordinatorDaemonId = readNonEmptyString2(loadConfig().machineId);
+  const coordinatorDaemonId = localCoordinatorDaemonId();
   if (!coordinatorDaemonId) return { mode: "skip", reason: "remote_auto_launch_no_coordinator_daemon_id" };
   return { mode: "remote", daemonId, coordinatorDaemonId };
 }
@@ -12235,31 +12205,12 @@ function activeReadonlyAssignedCount(meshId) {
   return getQueue(meshId, { status: ["assigned"] }).filter(isTaskReadonly).length;
 }
 function nodeHasActiveAssignment(meshId, nodeId) {
-  return getQueue(meshId, { status: ["assigned"] }).some((task) => task.assignedNodeId === nodeId);
+  return getQueue(meshId, { status: ["assigned"] }).some((task) => daemonIdsEquivalent(task.assignedNodeId, nodeId));
 }
 function nodeActiveLoad(meshId, nodeId) {
   return MeshRuntimeStore.getInstance().nodeActiveAssignmentCount(meshId, nodeId);
 }
-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) {
@@ -12284,7 +12235,7 @@ function orderEligibleNodes(meshId, strategy, nodes, opts) {
   });
 }
 function activeProviderAssignedCount(meshId, nodeId, providerType) {
-  return getQueue(meshId, { status: ["assigned"] }).filter((task) => task.assignedNodeId === nodeId && task.assignedProviderType === providerType).length;
+  return getQueue(meshId, { status: ["assigned"] }).filter((task) => daemonIdsEquivalent(task.assignedNodeId, nodeId) && task.assignedProviderType === providerType).length;
 }
 function sessionHasActiveAssignment(meshId, sessionId) {
   if (getQueue(meshId, { status: ["assigned"] }).some((task) => task.assignedSessionId === sessionId)) {
@@ -12303,7 +12254,7 @@ function liveSessionCountForNode(components, meshId, nodeId) {
     const settings = state.settings || {};
     if (readNonEmptyString2(settings.meshNodeFor) !== meshId) return false;
     const instNodeId = readNonEmptyString2(settings.meshNodeId) || readNonEmptyString2(settings.nodeId);
-    if (instNodeId !== nodeId) return false;
+    if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
     const status = readNonEmptyString2(state.status).toLowerCase();
     return !isTerminalSessionStatus(status);
   }).length;
@@ -12402,11 +12353,8 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
   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) {
@@ -12819,12 +12767,12 @@ var init_mesh_queue_assignment = __esm({
     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;
@@ -12925,8 +12873,8 @@ function recordUnroutableDelegateEvent(routing, eventName) {
   if (last !== void 0 && now - last < UNROUTABLE_DIAGNOSTIC_DEDUP_MS) return false;
   recentUnroutableDiagnostics.set(dedupKey, now);
   if (recentUnroutableDiagnostics.size > 256) {
-    for (const [key, ts2] of recentUnroutableDiagnostics) {
-      if (now - ts2 >= UNROUTABLE_DIAGNOSTIC_DEDUP_MS) recentUnroutableDiagnostics.delete(key);
+    for (const [key2, ts2] of recentUnroutableDiagnostics) {
+      if (now - ts2 >= UNROUTABLE_DIAGNOSTIC_DEDUP_MS) recentUnroutableDiagnostics.delete(key2);
     }
   }
   try {
@@ -13191,9 +13139,9 @@ async function updateDarwinMemoryCache() {
     for (const line of stdout.split("\n")) {
       const m = line.match(/^\s*Pages\s+([^:]+):\s+([\d,]+)\s*\.?/);
       if (!m) continue;
-      const key = m[1].trim().toLowerCase().replace(/\s+/g, "_");
+      const key2 = m[1].trim().toLowerCase().replace(/\s+/g, "_");
       const n = parseInt(m[2].replace(/,/g, ""), 10);
-      if (!Number.isNaN(n)) counts[key] = n;
+      if (!Number.isNaN(n)) counts[key2] = n;
     }
     const free = counts["free"] ?? 0;
     const inactive = counts["inactive"] ?? 0;
@@ -13417,7 +13365,7 @@ function trimStructuredStrings(value, maxChars) {
   if (Array.isArray(value)) return value.map((item) => trimStructuredStrings(item, maxChars));
   if (!value || typeof value !== "object") return value;
   return Object.fromEntries(
-    Object.entries(value).map(([key, nested]) => [key, trimStructuredStrings(nested, maxChars)])
+    Object.entries(value).map(([key2, nested]) => [key2, trimStructuredStrings(nested, maxChars)])
   );
 }
 function estimateBytes(value) {
@@ -14008,9 +13956,9 @@ function readMessageMeta(message) {
 function readStringField(value) {
   return typeof value === "string" ? value.trim().toLowerCase() : "";
 }
-function readRecordField(message, meta, key) {
+function readRecordField(message, meta, key2) {
   const record = message;
-  return record[key] ?? meta?.[key];
+  return record[key2] ?? meta?.[key2];
 }
 function readVisibilityField(message, meta) {
   return readStringField(readRecordField(message, meta, "visibility"));
@@ -14021,7 +13969,7 @@ function readTranscriptVisibilityField(message, meta) {
 }
 function hasBooleanMarker(message, meta, keys) {
   const record = message;
-  return keys.some((key) => record[key] === true || meta?.[key] === true);
+  return keys.some((key2) => record[key2] === true || meta?.[key2] === true);
 }
 function isActivityKind(kind) {
   return kind === "thought" || kind === "tool" || kind === "terminal";
@@ -14213,9 +14161,9 @@ function extractProviderControlValues(controls, data) {
   const values = {};
   const explicit = data.controlValues;
   if (explicit && typeof explicit === "object") {
-    for (const [key, value] of Object.entries(explicit)) {
+    for (const [key2, value] of Object.entries(explicit)) {
       if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-        values[key] = value;
+        values[key2] = value;
       }
     }
   }
@@ -14679,26 +14627,26 @@ function getGitSummaryForWorkspace(workspace, options) {
   if (!workspace) return void 0;
   return options.getGitSummaryForWorkspace?.(workspace) || void 0;
 }
-function findCdpManager(cdpManagers, key) {
-  const exact = cdpManagers.get(key);
+function findCdpManager(cdpManagers, key2) {
+  const exact = cdpManagers.get(key2);
   if (exact) return exact.isConnected ? exact : null;
-  const prefix = key + "_";
+  const prefix = key2 + "_";
   const matches = [...cdpManagers.entries()].filter(([k, m]) => m.isConnected && k.startsWith(prefix));
   if (matches.length === 1) return matches[0][1];
   return null;
 }
-function hasCdpManager(cdpManagers, key) {
-  if (cdpManagers.has(key)) return true;
-  const prefix = key + "_";
+function hasCdpManager(cdpManagers, key2) {
+  if (cdpManagers.has(key2)) return true;
+  const prefix = key2 + "_";
   for (const k of cdpManagers.keys()) {
     if (k.startsWith(prefix)) return true;
   }
   return false;
 }
-function isCdpConnected(cdpManagers, key) {
-  const exact = cdpManagers.get(key);
+function isCdpConnected(cdpManagers, key2) {
+  const exact = cdpManagers.get(key2);
   if (exact?.isConnected) return true;
-  const prefix = key + "_";
+  const prefix = key2 + "_";
   for (const [k, m] of cdpManagers.entries()) {
     if (m.isConnected && k.startsWith(prefix)) return true;
   }
@@ -15035,11 +14983,11 @@ function buildRecentReadDebugSignature(snapshot) {
     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) {
@@ -16594,9 +16542,9 @@ function recordHeldTerminalEventsToLedger(meshId, drainDaemonIds, reason, heldFo
   for (const event of pending) {
     if (!shouldForceInjectMeshEvent(event.event)) continue;
     const fingerprint = buildPendingEventFingerprint(event);
-    const key = `${meshId}::${fingerprint || `${event.event}::${event.nodeId || ""}::${event.queuedAt}`}`;
-    if (heldEventLedgerRecorded.has(key)) continue;
-    heldEventLedgerRecorded.add(key);
+    const key2 = `${meshId}::${fingerprint || `${event.event}::${event.nodeId || ""}::${event.queuedAt}`}`;
+    if (heldEventLedgerRecorded.has(key2)) continue;
+    heldEventLedgerRecorded.add(key2);
     const finalSummary = readMeshCompletionSummary(event.metadataEvent);
     try {
       appendLedgerEntry(meshId, {
@@ -16617,7 +16565,7 @@ function recordHeldTerminalEventsToLedger(meshId, drainDaemonIds, reason, heldFo
       });
       LOG.info("MeshReconcile", `Ledger-recorded held ${event.event} for mesh ${meshId} (reason ${reason}) \u2014 recoverable from ledger`);
     } catch (e) {
-      heldEventLedgerRecorded.delete(key);
+      heldEventLedgerRecorded.delete(key2);
       LOG.warn("MeshReconcile", `Failed to ledger-record held ${event.event} for mesh ${meshId}: ${e?.message || e}`);
     }
   }
@@ -17082,9 +17030,9 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
   const activeTaskKeys = new Set(
     dispatches.map((d) => readNonEmptyString2(d.taskId)).filter(Boolean).map((taskId) => inFlightSynthKey(mesh.id, taskId))
   );
-  for (const key of inFlightAckedHoldState.keys()) {
-    if (key.startsWith(`${mesh.id}::`) && !activeTaskKeys.has(key)) {
-      inFlightAckedHoldState.delete(key);
+  for (const key2 of inFlightAckedHoldState.keys()) {
+    if (key2.startsWith(`${mesh.id}::`) && !activeTaskKeys.has(key2)) {
+      inFlightAckedHoldState.delete(key2);
     }
   }
   const dispatchMeshCommand = components.dispatchMeshCommand;
@@ -18670,8 +18618,8 @@ function extractButtonsFromRule(rule, hay) {
         label += " " + next.trim();
         j += 1;
       }
-      const key = keyTemplate.replace(/\{index\}/g, String(idx));
-      buttons.push({ index: idx, label, key, current });
+      const key2 = keyTemplate.replace(/\{index\}/g, String(idx));
+      buttons.push({ index: idx, label, key: key2, current });
       i = j - 1;
     }
   } else {
@@ -18681,8 +18629,8 @@ function extractButtonsFromRule(rule, hay) {
       const idx = Number(m[1]);
       const label = String(m[2] ?? "").trim();
       if (!Number.isFinite(idx) || idx <= 0 || !label) continue;
-      const key = keyTemplate.replace(/\{index\}/g, String(idx));
-      buttons.push({ index: idx, label, key, current: hasCursorMarker(m[0]) });
+      const key2 = keyTemplate.replace(/\{index\}/g, String(idx));
+      buttons.push({ index: idx, label, key: key2, current: hasCursorMarker(m[0]) });
     }
   }
   const block2 = lastContiguousNumberedBlock(buttons);
@@ -18762,12 +18710,12 @@ function evalCond(cond, sections, fullScreen, cursor, prevLines, clock, legacyTr
     return { kind: "elapsed", result, detail: `elapsed ${age}ms / ${cond.elapsed_ms}ms`, remainingMs };
   }
   if (isStable(cond)) {
-    const key = regionKey(cond.cursor_above);
-    const lastChanged = clock.regionLastChangedAt.get(key) ?? clock.stateEnteredAt;
+    const key2 = regionKey(cond.cursor_above);
+    const lastChanged = clock.regionLastChangedAt.get(key2) ?? clock.stateEnteredAt;
     const stableFor = clock.now - lastChanged;
     const result = stableFor >= cond.stable_ms;
     const remainingMs = result ? 0 : cond.stable_ms - stableFor;
-    const where = key === WHOLE_SCREEN ? "screen" : `cursor_above=${cond.cursor_above}`;
+    const where = key2 === WHOLE_SCREEN ? "screen" : `cursor_above=${cond.cursor_above}`;
     return { kind: "stable", result, detail: `stable ${where} ${stableFor}ms / ${cond.stable_ms}ms`, remainingMs };
   }
   if (isRegex(cond) || isChanged(cond)) {
@@ -22711,16 +22659,16 @@ function normalizeModuleName(request) {
 }
 function buildFsShim() {
   const shim = {};
-  for (const key of FS_READ_ONLY_MEMBERS) {
-    if (key === "promises") continue;
-    const real = nodeFs[key];
-    if (real !== void 0) shim[key] = real;
+  for (const key2 of FS_READ_ONLY_MEMBERS) {
+    if (key2 === "promises") continue;
+    const real = nodeFs[key2];
+    if (real !== void 0) shim[key2] = real;
   }
   const realPromises = nodeFs.promises || {};
   const promisesShim = {};
-  for (const key of FS_PROMISES_READ_ONLY_MEMBERS) {
-    const real = realPromises[key];
-    if (real !== void 0) promisesShim[key] = real;
+  for (const key2 of FS_PROMISES_READ_ONLY_MEMBERS) {
+    const real = realPromises[key2];
+    if (real !== void 0) promisesShim[key2] = real;
   }
   shim.promises = promisesShim;
   return shim;
@@ -22803,10 +22751,10 @@ function _uninstallProviderProcessShimForTest() {
 function buildProcessShim() {
   const real = globalThis.process;
   const shim = /* @__PURE__ */ Object.create(null);
-  for (const key of Object.keys(real)) {
-    if (DANGEROUS_PROCESS_METHODS.has(String(key))) continue;
+  for (const key2 of Object.keys(real)) {
+    if (DANGEROUS_PROCESS_METHODS.has(String(key2))) continue;
     try {
-      shim[key] = real[key];
+      shim[key2] = real[key2];
     } catch {
     }
   }
@@ -23611,10 +23559,10 @@ var GitWorkspaceMonitor = class {
     const compactSummary = createGitCompactSummary(status, diffSummary);
     const timestamp = this.now();
     const seq = ++this.seq;
-    const key = this.keyForWorkspace(normalized.workspace);
+    const key2 = this.keyForWorkspace(normalized.workspace);
     const update = {
       topic: "workspace.git",
-      key,
+      key: key2,
       workspace: normalized.workspace,
       status,
       diffSummary,
@@ -23622,7 +23570,7 @@ var GitWorkspaceMonitor = class {
       timestamp
     };
     const cacheEntry = {
-      key,
+      key: key2,
       workspace: normalized.workspace,
       status,
       diffSummary,
@@ -23766,11 +23714,11 @@ function validateRepoPath(args) {
   }
   return { path: args.path.trim() };
 }
-function validateSnapshotId(args, key) {
-  if (typeof args?.[key] !== "string" || !args[key].trim()) {
-    return failure("invalid_args", `${key} must be a non-empty string`);
+function validateSnapshotId(args, key2) {
+  if (typeof args?.[key2] !== "string" || !args[key2].trim()) {
+    return failure("invalid_args", `${key2} must be a non-empty string`);
   }
-  return args[key].trim();
+  return args[key2].trim();
 }
 function parseSnapshotReason(args) {
   if (args?.reason === void 0 || args?.reason === null || args?.reason === "") {
@@ -24252,6 +24200,29 @@ init_mesh_review_inbox();
 init_coordinator_registry();
 init_refine_config();
 init_worktree_bootstrap_config();
+
+// src/config/repo-settings.ts
+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)
+  };
+}
+
+// src/index.ts
 init_mesh_ledger();
 init_mesh_fast_forward();
 
@@ -24438,7 +24409,7 @@ init_state_store();
 // src/detection/ide-detector.ts
 import { exec as exec3 } from "child_process";
 import { promisify as promisify5 } from "util";
-import { existsSync as existsSync20, statSync as statSync9 } from "fs";
+import { existsSync as existsSync20, statSync as statSync8 } from "fs";
 import { platform as platform5, homedir as homedir8 } from "os";
 import * as path14 from "path";
 
@@ -24530,7 +24501,7 @@ function findCliCommand(command) {
       const fullPath = path14.join(p, trimmed + ext);
       try {
         if (existsSync20(fullPath)) {
-          const stat2 = statSync9(fullPath);
+          const stat2 = statSync8(fullPath);
           if (stat2.isFile() && (isWin || stat2.mode & 73)) {
             return fullPath;
           }
@@ -26159,10 +26130,10 @@ var StatusMonitor = class {
     return events;
   }
   /** Cooldown check — prevent sending the same notification too frequently */
-  shouldAlert(key, now) {
-    const last = this.lastAlertTime.get(key) || 0;
+  shouldAlert(key2, now) {
+    const last = this.lastAlertTime.get(key2) || 0;
     if (now - last > this.config.alertCooldownSec * 1e3) {
-      this.lastAlertTime.set(key, now);
+      this.lastAlertTime.set(key2, now);
       return true;
     }
     return false;
@@ -26210,16 +26181,16 @@ var savedHistoryBackgroundRefresh = /* @__PURE__ */ new Set();
 var savedHistoryRollupInFlight = /* @__PURE__ */ new Set();
 var BOUNDED_TAIL_CACHE_MAX_ENTRIES = 64;
 var boundedTailReadCache = /* @__PURE__ */ new Map();
-function readBoundedTailCache(key, signature) {
-  const cached3 = boundedTailReadCache.get(key);
+function readBoundedTailCache(key2, signature) {
+  const cached3 = boundedTailReadCache.get(key2);
   if (!cached3 || cached3.signature !== signature) return null;
-  boundedTailReadCache.delete(key);
-  boundedTailReadCache.set(key, cached3);
+  boundedTailReadCache.delete(key2);
+  boundedTailReadCache.set(key2, cached3);
   return cached3.result;
 }
-function writeBoundedTailCache(key, signature, result) {
-  boundedTailReadCache.delete(key);
-  boundedTailReadCache.set(key, { signature, result });
+function writeBoundedTailCache(key2, signature, result) {
+  boundedTailReadCache.delete(key2);
+  boundedTailReadCache.set(key2, { signature, result });
   while (boundedTailReadCache.size > BOUNDED_TAIL_CACHE_MAX_ENTRIES) {
     const oldest = boundedTailReadCache.keys().next().value;
     if (oldest === void 0) break;
@@ -26655,21 +26626,21 @@ function shouldScheduleSavedHistoryRollupForSignature(signature) {
   return shouldScheduleSavedHistoryRollup(size);
 }
 function scheduleSavedHistoryRollup(agentType, historySessionId) {
-  const key = `${agentType}:${historySessionId}`;
-  if (!historySessionId || savedHistoryRollupInFlight.has(key)) return;
-  savedHistoryRollupInFlight.add(key);
+  const key2 = `${agentType}:${historySessionId}`;
+  if (!historySessionId || savedHistoryRollupInFlight.has(key2)) return;
+  savedHistoryRollupInFlight.add(key2);
   setTimeout(() => {
     try {
       new ChatHistoryWriter().compactHistorySession(agentType, historySessionId);
     } finally {
-      savedHistoryRollupInFlight.delete(key);
+      savedHistoryRollupInFlight.delete(key2);
     }
   }, 0);
 }
 function scheduleSavedHistoryBackgroundRefresh(agentType, dir) {
-  const key = `${agentType}:${dir}`;
-  if (savedHistoryBackgroundRefresh.has(key)) return;
-  savedHistoryBackgroundRefresh.add(key);
+  const key2 = `${agentType}:${dir}`;
+  if (savedHistoryBackgroundRefresh.has(key2)) return;
+  savedHistoryBackgroundRefresh.add(key2);
   setTimeout(() => {
     try {
       if (!fs6.existsSync(dir)) return;
@@ -26689,7 +26660,7 @@ function scheduleSavedHistoryBackgroundRefresh(agentType, dir) {
       }
     } catch {
     } finally {
-      savedHistoryBackgroundRefresh.delete(key);
+      savedHistoryBackgroundRefresh.delete(key2);
     }
   }, 0);
 }
@@ -27455,14 +27426,14 @@ function rewriteCanonicalSavedHistory(agentType, historySessionId, records) {
     return false;
   }
 }
-function getNativeHistoryScriptName(canonicalHistory, key) {
-  const configured = canonicalHistory?.scripts?.[key];
+function getNativeHistoryScriptName(canonicalHistory, key2) {
+  const configured = canonicalHistory?.scripts?.[key2];
   if (typeof configured === "string" && configured.trim()) return configured.trim();
-  return key === "readSession" ? "readNativeHistory" : "listNativeHistory";
+  return key2 === "readSession" ? "readNativeHistory" : "listNativeHistory";
 }
-function getProviderNativeHistoryScript(scripts, canonicalHistory, key) {
+function getProviderNativeHistoryScript(scripts, canonicalHistory, key2) {
   if (!canonicalHistory?.scripts) return null;
-  const fn = scripts?.[getNativeHistoryScriptName(canonicalHistory, key)];
+  const fn = scripts?.[getNativeHistoryScriptName(canonicalHistory, key2)];
   return typeof fn === "function" ? fn : null;
 }
 function normalizeProviderNativeHistoryRecords(agentType, historySessionId, records) {
@@ -28196,11 +28167,11 @@ function validateControlValues(controlValues, source) {
     throw new Error(`${source}: controlValues must be an object when provided`);
   }
   const normalized = {};
-  for (const [key, value] of Object.entries(controlValues)) {
+  for (const [key2, value] of Object.entries(controlValues)) {
     if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
-      throw new Error(`${source}: controlValues.${key} must be string, number, or boolean`);
+      throw new Error(`${source}: controlValues.${key2} must be string, number, or boolean`);
     }
-    normalized[key] = value;
+    normalized[key2] = value;
   }
   return normalized;
 }
@@ -28953,7 +28924,7 @@ var DaemonCdpScanner = class {
       for (const [ide, ports] of Object.entries(portMap)) {
         const primaryPort = ports[0];
         const alreadyConnected = [...this.ctx.cdpManagers.entries()].some(
-          ([key, m]) => m.isConnected && (key === ide || key.startsWith(ide + "_"))
+          ([key2, m]) => m.isConnected && (key2 === ide || key2.startsWith(ide + "_"))
         );
         if (alreadyConnected) continue;
         if (this.opts.multiWindow) {
@@ -29127,8 +29098,8 @@ var DaemonCdpInitializer = class {
     for (let i = 0; i < targets.length; i++) {
       const target = targets[i];
       let alreadyTracked = false;
-      for (const [key, m] of cdpManagers.entries()) {
-        if ((key === ide || key.startsWith(`${ide}_`)) && m.targetId === target.id) {
+      for (const [key2, m] of cdpManagers.entries()) {
+        if ((key2 === ide || key2.startsWith(`${ide}_`)) && m.targetId === target.id) {
           alreadyTracked = true;
           break;
         }
@@ -29160,29 +29131,29 @@ var DaemonCdpInitializer = class {
   async pruneStaleManagers(port, ide, targets) {
     const trackedTargetIds = new Set(targets.map((target) => target.id));
     const removals = [];
-    for (const [key, manager] of this.config.cdpManagers.entries()) {
-      if (!(key === ide || key.startsWith(`${ide}_`))) continue;
+    for (const [key2, manager] of this.config.cdpManagers.entries()) {
+      if (!(key2 === ide || key2.startsWith(`${ide}_`))) continue;
       if (manager.getPort() !== port) continue;
       if (targets.length === 0) {
-        removals.push({ key, manager, reason: "ide_closed" });
+        removals.push({ key: key2, manager, reason: "ide_closed" });
         continue;
       }
       if (manager.targetId && !trackedTargetIds.has(manager.targetId)) {
-        removals.push({ key, manager, reason: "target_closed" });
+        removals.push({ key: key2, manager, reason: "target_closed" });
         continue;
       }
-      if (key === ide && !manager.targetId && targets.length > 1) {
-        removals.push({ key, manager, reason: "target_rekeyed" });
+      if (key2 === ide && !manager.targetId && targets.length > 1) {
+        removals.push({ key: key2, manager, reason: "target_rekeyed" });
       }
     }
-    for (const { key, manager, reason } of removals) {
+    for (const { key: key2, manager, reason } of removals) {
       try {
         manager.disconnect();
       } catch {
       }
-      this.config.cdpManagers.delete(key);
-      LOG.info("IDE", `Detached window: ${key} (${reason})`);
-      await this.config.onDisconnected?.(ide, manager, key, reason);
+      this.config.cdpManagers.delete(key2);
+      LOG.info("IDE", `Detached window: ${key2} (${reason})`);
+      await this.config.onDisconnected?.(ide, manager, key2, reason);
     }
   }
   // ─── Periodic scanning ───
@@ -29508,7 +29479,7 @@ function sanitizeTraceValue(value, traceContent) {
     if (Array.isArray(value)) return value.map((entry) => sanitizeTraceValue(entry, traceContent));
     if (value && typeof value === "object") {
       return Object.fromEntries(
-        Object.entries(value).map(([key, nested]) => [key, sanitizeTraceValue(nested, traceContent)])
+        Object.entries(value).map(([key2, nested]) => [key2, sanitizeTraceValue(nested, traceContent)])
       );
     }
     return value;
@@ -29517,7 +29488,7 @@ function sanitizeTraceValue(value, traceContent) {
   if (Array.isArray(value)) return value.map((entry) => sanitizeTraceValue(entry, traceContent));
   if (value && typeof value === "object") {
     return Object.fromEntries(
-      Object.entries(value).map(([key, nested]) => [key, sanitizeTraceValue(nested, traceContent)])
+      Object.entries(value).map(([key2, nested]) => [key2, sanitizeTraceValue(nested, traceContent)])
     );
   }
   return value;
@@ -29825,8 +29796,8 @@ function maxSequence(messages) {
 }
 function isSupersetOf(candidate, required) {
   if (required.size === 0) return true;
-  for (const key of required) {
-    if (!candidate.has(key)) return false;
+  for (const key2 of required) {
+    if (!candidate.has(key2)) return false;
   }
   return true;
 }
@@ -29839,17 +29810,17 @@ function chatSourceSessionKey(providerType, sessionId) {
 var ChatSourceRegistry = class {
   records = /* @__PURE__ */ new Map();
   /** Snapshot of current state for diagnostics. Does not mutate. */
-  getState(key) {
-    return this.records.get(key)?.state ?? INITIAL_CHAT_SOURCE_STATE;
+  getState(key2) {
+    return this.records.get(key2)?.state ?? INITIAL_CHAT_SOURCE_STATE;
   }
   /** Recent transitions, newest last. Empty array when nothing has happened. */
-  getTransitions(key) {
-    return this.records.get(key)?.transitions ?? [];
+  getTransitions(key2) {
+    return this.records.get(key2)?.transitions ?? [];
   }
   /** Drop a session. Caller should invoke this when the session is destroyed
    *  to avoid unbounded growth across long-lived daemons. */
-  clear(key) {
-    this.records.delete(key);
+  clear(key2) {
+    this.records.delete(key2);
   }
   /** Drop all sessions. Test helper. */
   clearAll() {
@@ -29861,15 +29832,15 @@ var ChatSourceRegistry = class {
    * under `key`; callers may treat the decision as authoritative without
    * re-reading.
    */
-  observe(key, observation, at = Date.now()) {
-    const prev = this.records.get(key);
+  observe(key2, observation, at = Date.now()) {
+    const prev = this.records.get(key2);
     const prevState = prev?.state ?? INITIAL_CHAT_SOURCE_STATE;
     const prevLockedSince = prev?.lockedSince;
     const result = transitionChatSourceState(prevState, observation, at, prevLockedSince);
     const transitions = prev?.transitions ?? [];
     const nextTransitions = appendTransition(transitions, result.transition);
     const lockedSince = result.lockState.lockedSince;
-    this.records.set(key, {
+    this.records.set(key2, {
       state: result.next,
       lockedSince,
       transitions: nextTransitions
@@ -30552,8 +30523,8 @@ function readLiveCodexWorkspaceNativeHistory(agentStr, args) {
   });
   return { ...history, lookup: "workspace" };
 }
-function shouldPreserveReadChatPayloadField(key) {
-  return key === "messageSource" || key === "transcriptProvenance";
+function shouldPreserveReadChatPayloadField(key2) {
+  return key2 === "messageSource" || key2 === "transcriptProvenance";
 }
 function updateMessageSourceReturnedCount(value, returnedMessageCount) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return value;
@@ -30723,7 +30694,7 @@ function buildReadChatCommandResult(payload, args, h) {
   const visibleMessages = includeActivity ? filteredMessages.filter((m) => isUserFacingChatMessage(m) || isActivityChatMessage(m)) : filterUserFacingChatMessages(filteredMessages);
   const sync = buildFullTail(visibleMessages, normalizeReadChatTailLimit(args));
   const hiddenMsgCount = Math.max(0, messages.length - visibleMessages.length);
-  const preservedPayloadFields = Object.fromEntries(Object.entries(payload).filter(([key]) => shouldPreserveReadChatPayloadField(key)));
+  const preservedPayloadFields = Object.fromEntries(Object.entries(payload).filter(([key2]) => shouldPreserveReadChatPayloadField(key2)));
   if (preservedPayloadFields.messageSource) {
     preservedPayloadFields.messageSource = updateMessageSourceReturnedCount(preservedPayloadFields.messageSource, sync.messages.length);
   }
@@ -31475,8 +31446,8 @@ function sanitizeDebugBundleValue(value, options = {}, depth = 0, keyHint = "")
   const record = value;
   const result = {};
   const entries = Object.entries(record).slice(0, normalizedOptions.maxObjectKeys);
-  for (const [key, item] of entries) {
-    result[key] = sanitizeDebugBundleValue(item, normalizedOptions, depth + 1, key);
+  for (const [key2, item] of entries) {
+    result[key2] = sanitizeDebugBundleValue(item, normalizedOptions, depth + 1, key2);
   }
   const remaining = Object.keys(record).length - entries.length;
   if (remaining > 0) result.__truncatedKeys = remaining;
@@ -31802,14 +31773,14 @@ function callLegacyTextScript(script, text) {
   if (typeof script !== "function") return null;
   return script(text);
 }
-function isRecentDuplicateSend(key) {
+function isRecentDuplicateSend(key2) {
   const now = Date.now();
   for (const [candidate, ts2] of recentSendByTarget.entries()) {
     if (now - ts2 > RECENT_SEND_WINDOW_MS) recentSendByTarget.delete(candidate);
   }
-  const previous = recentSendByTarget.get(key);
+  const previous = recentSendByTarget.get(key2);
   if (previous && now - previous <= RECENT_SEND_WINDOW_MS) return true;
-  recentSendByTarget.set(key, now);
+  recentSendByTarget.set(key2, now);
   return false;
 }
 function didProviderConfirmSend(result) {
@@ -32672,23 +32643,23 @@ async function handleCdpRemoteAction(h, args) {
   try {
     switch (action) {
       case "input_key": {
-        const { type: evType, key, code, text, unmodifiedText, modifiers } = params;
+        const { type: evType, key: key2, code, text, unmodifiedText, modifiers } = params;
         const mod = typeof modifiers === "number" ? modifiers : 0;
-        const vk = KEY_TO_VK[key] || (key.length === 1 ? key.charCodeAt(0) : 0);
+        const vk = KEY_TO_VK[key2] || (key2.length === 1 ? key2.charCodeAt(0) : 0);
         if (evType === "char") {
           await h.getCdp().send("Input.dispatchKeyEvent", {
             type: "char",
-            key,
+            key: key2,
             code,
-            text: text || key,
-            unmodifiedText: unmodifiedText || text || key,
+            text: text || key2,
+            unmodifiedText: unmodifiedText || text || key2,
             ...vk ? { windowsVirtualKeyCode: vk, nativeVirtualKeyCode: vk } : {},
             ...mod ? { modifiers: mod } : {}
           });
         } else {
           await h.getCdp().send("Input.dispatchKeyEvent", {
             type: "rawKeyDown",
-            key,
+            key: key2,
             code,
             ...text ? { text } : {},
             ...vk ? { windowsVirtualKeyCode: vk, nativeVirtualKeyCode: vk } : {},
@@ -32696,7 +32667,7 @@ async function handleCdpRemoteAction(h, args) {
           });
           await h.getCdp().send("Input.dispatchKeyEvent", {
             type: "keyUp",
-            key,
+            key: key2,
             code,
             ...vk ? { windowsVirtualKeyCode: vk, nativeVirtualKeyCode: vk } : {},
             ...mod ? { modifiers: mod } : {}
@@ -33095,21 +33066,21 @@ function handleGetProviderSettings(h, args) {
 }
 async function handleSetProviderSetting(h, args) {
   const loader = h.ctx.providerLoader;
-  const { providerType, key, value } = args || {};
-  if (!providerType || !key || value === void 0) {
+  const { providerType, key: key2, value } = args || {};
+  if (!providerType || !key2 || value === void 0) {
     return { success: false, error: "providerType, key, and value are required" };
   }
-  const result = loader?.setSetting(providerType, key, value);
+  const result = loader?.setSetting(providerType, key2, value);
   if (result) {
     if (h.ctx.instanceManager) {
       const allSettings = loader?.getSettings(providerType) || {};
       const updated = h.ctx.instanceManager.updateInstanceSettings(providerType, allSettings);
-      LOG.info("Command", `[set_provider_setting] ${providerType}.${key}=${JSON.stringify(value)} \u2192 ${updated} instance(s) updated`);
+      LOG.info("Command", `[set_provider_setting] ${providerType}.${key2}=${JSON.stringify(value)} \u2192 ${updated} instance(s) updated`);
     }
-    await h.ctx.onProviderSettingChanged?.(providerType, key, value);
-    return { success: true, providerType, key, value };
+    await h.ctx.onProviderSettingChanged?.(providerType, key2, value);
+    return { success: true, providerType, key: key2, value };
   }
-  return { success: false, error: `Failed to set ${providerType}.${key} \u2014 invalid key, value, or not a public setting` };
+  return { success: false, error: `Failed to set ${providerType}.${key2} \u2014 invalid key, value, or not a public setting` };
 }
 function handleGetProviderSourceConfig(h, _args) {
   const loader = h.ctx.providerLoader;
@@ -33155,9 +33126,9 @@ function normalizeProviderScriptArgs(args, scriptName) {
       normalizedArgs.mode = normalizedArgs.value;
     }
   }
-  for (const key of ["mode", "model", "message", "action", "button", "text", "sessionId", "value"]) {
-    if (key in normalizedArgs && !(key.toUpperCase() in normalizedArgs)) {
-      normalizedArgs[key.toUpperCase()] = normalizedArgs[key];
+  for (const key2 of ["mode", "model", "message", "action", "button", "text", "sessionId", "value"]) {
+    if (key2 in normalizedArgs && !(key2.toUpperCase() in normalizedArgs)) {
+      normalizedArgs[key2.toUpperCase()] = normalizedArgs[key2];
     }
   }
   return normalizedArgs;
@@ -33557,10 +33528,10 @@ function summarizeCommandArgs(args) {
     "value"
   ];
   const entries = [];
-  for (const key of preferredKeys) {
-    if (!(key in args) || args[key] === void 0) continue;
-    const value = key === "text" || key === "message" ? `${String(args[key] || "").length} chars` : key === "data" ? `${String(args[key] || "").length} chars` : summarizeLogValue(args[key]);
-    entries.push(`${key}=${value}`);
+  for (const key2 of preferredKeys) {
+    if (!(key2 in args) || args[key2] === void 0) continue;
+    const value = key2 === "text" || key2 === "message" ? `${String(args[key2] || "").length} chars` : key2 === "data" ? `${String(args[key2] || "").length} chars` : summarizeLogValue(args[key2]);
+    entries.push(`${key2}=${value}`);
   }
   return entries.length ? entries.join(" ") : "{...}";
 }
@@ -33612,12 +33583,12 @@ var DaemonCommandHandler = class {
    * Get provider module — _currentProviderType (agentType priority) use.
    */
   getProvider(overrideType) {
-    const key = overrideType || this._currentRoute.providerType || this._currentRoute.session?.providerType || this._currentRoute.managerKey;
-    if (!key || !this._ctx.providerLoader) return void 0;
-    const result = this._ctx.providerLoader.resolve(key);
+    const key2 = overrideType || this._currentRoute.providerType || this._currentRoute.session?.providerType || this._currentRoute.managerKey;
+    if (!key2 || !this._ctx.providerLoader) return void 0;
+    const result = this._ctx.providerLoader.resolve(key2);
     if (result) return result;
-    const baseType = key.split("_")[0];
-    if (baseType !== key) return this._ctx.providerLoader.resolve(baseType);
+    const baseType = key2.split("_")[0];
+    if (baseType !== key2) return this._ctx.providerLoader.resolve(baseType);
     return void 0;
   }
   /** Get a provider script by name from ProviderLoader. */
@@ -33675,11 +33646,11 @@ var DaemonCommandHandler = class {
     return this._ctx.adapters.get(target) || null;
   }
   // ─── Private helpers ──────────────────────────────
-  inferProviderType(key) {
-    if (!key) return void 0;
-    const session = this._ctx.sessionRegistry?.get(key);
+  inferProviderType(key2) {
+    if (!key2) return void 0;
+    const session = this._ctx.sessionRegistry?.get(key2);
     if (session?.providerType) return session.providerType;
-    return key.split("_")[0];
+    return key2.split("_")[0];
   }
   resolveRoute(args) {
     const targetSessionId = typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : "";
@@ -35377,16 +35348,16 @@ var coordinatorPromptHandlers = {
           const m = matchAppend || matchOverride;
           if (!m) continue;
           const isAppend = !!matchAppend;
-          const key = m[1];
+          const key2 = m[1];
           const full = path43.join(dir, name);
           let content = "";
           try {
             content = fs38.readFileSync(full, "utf8");
           } catch {
           }
-          if (!entries[key]) entries[key] = { override: "", append: "" };
-          if (isAppend) entries[key].append = content;
-          else entries[key].override = content;
+          if (!entries[key2]) entries[key2] = { override: "", append: "" };
+          if (isAppend) entries[key2].append = content;
+          else entries[key2].override = content;
         }
       }
     } catch (error) {
@@ -35398,14 +35369,14 @@ var coordinatorPromptHandlers = {
     const fs38 = await import("fs");
     const path43 = await import("path");
     const os30 = await import("os");
-    const key = typeof args?.key === "string" ? args.key.trim() : "";
+    const key2 = typeof args?.key === "string" ? args.key.trim() : "";
     const kind = args?.kind === "append" ? "append" : "override";
     const content = typeof args?.content === "string" ? args.content : "";
-    if (!key || !/^[a-zA-Z0-9_.-]+$/.test(key)) {
+    if (!key2 || !/^[a-zA-Z0-9_.-]+$/.test(key2)) {
       return { success: false, error: "key must match [a-zA-Z0-9_.-]+" };
     }
     const dir = path43.join(os30.homedir(), ".adhdev", "coordinator-prompts");
-    const filename = kind === "append" ? `${key}.append.md` : `${key}.md`;
+    const filename = kind === "append" ? `${key2}.append.md` : `${key2}.md`;
     const full = path43.join(dir, filename);
     try {
       fs38.mkdirSync(dir, { recursive: true });
@@ -35414,7 +35385,7 @@ var coordinatorPromptHandlers = {
       } else if (fs38.existsSync(full)) {
         fs38.unlinkSync(full);
       }
-      return { success: true, path: full, kind, key };
+      return { success: true, path: full, kind, key: key2 };
     } catch (error) {
       return { success: false, error: error?.message || String(error) };
     }
@@ -36359,7 +36330,7 @@ var RULES = [
   {
     name: "key_value_secret",
     pattern: /\b([A-Z0-9_]*(?:SECRET|TOKEN|API[_-]?KEY|PASSWORD|PASSWD|PRIVATE[_-]?KEY|CREDENTIAL|CLIENT[_-]?SECRET)[A-Z0-9_]*)(\s*[:=]\s*)(["']?)([^\s"',;]+)\3/gi,
-    replace: (_m, key, delim, quote) => `${key}${delim}${quote}${MASK}${quote}`
+    replace: (_m, key2, delim, quote) => `${key2}${delim}${quote}${MASK}${quote}`
   },
   // Authorization: Bearer <token>
   {
@@ -36709,7 +36680,7 @@ function realWorkspacePath(workingDir) {
 }
 function applyPreLaunchTrust(trust, workingDir) {
   const settingsPath = expandHome2(trust.settings_path);
-  const key = trust.key;
+  const key2 = trust.key;
   const real = realWorkspacePath(workingDir);
   try {
     let parsed = {};
@@ -36722,18 +36693,18 @@ function applyPreLaunchTrust(trust, workingDir) {
         }
       }
     }
-    const existing = parsed[key];
+    const existing = parsed[key2];
     const list = Array.isArray(existing) ? existing.filter((v) => typeof v === "string") : [];
     if (list.includes(real)) {
       LOG.debug("pre-launch-trust", `[${trust.settings_path}] ${real} already trusted \u2014 no change`);
       return null;
     }
     list.push(real);
-    parsed[key] = list;
+    parsed[key2] = list;
     fs14.mkdirSync(path22.dirname(settingsPath), { recursive: true });
     fs14.writeFileSync(settingsPath, `${JSON.stringify(parsed, null, 2)}
 `, "utf8");
-    LOG.info("pre-launch-trust", `pre-trusted workspace in ${trust.settings_path} (key="${key}")`);
+    LOG.info("pre-launch-trust", `pre-trusted workspace in ${trust.settings_path} (key="${key2}")`);
     return real;
   } catch (err) {
     LOG.warn("pre-launch-trust", `failed to pre-trust workspace in ${trust.settings_path}: ${err.message}`);
@@ -38344,8 +38315,8 @@ function jsonPathGet(record, expr) {
     }
     let end = i;
     while (end < expr.length && expr[end] !== "." && expr[end] !== "[") end += 1;
-    const key = expr.slice(i, end);
-    cur = cur[key];
+    const key2 = expr.slice(i, end);
+    cur = cur[key2];
     i = end;
   }
   return cur;
@@ -40320,8 +40291,8 @@ var CliProviderInstance = class _CliProviderInstance {
   /** Drop user-input ack entries older than the dedup window so the map can't grow unbounded. */
   pruneRecentUserInputAcks(now) {
     if (this.recentUserInputAcks.size <= 1) return;
-    for (const [key, at] of this.recentUserInputAcks) {
-      if (now - at > USER_INPUT_ACK_DEDUP_WINDOW_MS) this.recentUserInputAcks.delete(key);
+    for (const [key2, at] of this.recentUserInputAcks) {
+      if (now - at > USER_INPUT_ACK_DEDUP_WINDOW_MS) this.recentUserInputAcks.delete(key2);
     }
   }
   dispose() {
@@ -41525,8 +41496,8 @@ ${effect.notification.body || ""}`.trim();
     };
     const isRuntimeOverlay = (entry) => {
       if (entry.source !== "runtime") return false;
-      const key = typeof entry.runtimeKey === "string" ? entry.runtimeKey.trim().toLowerCase() : "";
-      if (key.startsWith("auto_approval:")) return true;
+      const key2 = typeof entry.runtimeKey === "string" ? entry.runtimeKey.trim().toLowerCase() : "";
+      if (key2.startsWith("auto_approval:")) return true;
       return !isUserFacingChatMessage(entry.message);
     };
     const shouldKeepParsedBeforeUntimedRuntime = (message) => {
@@ -43136,16 +43107,16 @@ var DEFAULT_COORDINATOR_DELEGATED_ENV_UNSETS = [
 function hasCliArg(args, flag) {
   return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
 }
-function hasConfigOverride(args, key) {
+function hasConfigOverride(args, key2) {
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
     const next = args[index + 1];
     if ((arg === "-c" || arg === "--config") && typeof next === "string") {
-      if (next === key || next.startsWith(`${key}=`) || next.startsWith(`${key}.`)) return true;
+      if (next === key2 || next.startsWith(`${key2}=`) || next.startsWith(`${key2}.`)) return true;
     }
     if (arg.startsWith("--config=")) {
       const value = arg.slice("--config=".length);
-      if (value === key || value.startsWith(`${key}=`) || value.startsWith(`${key}.`)) return true;
+      if (value === key2 || value.startsWith(`${key2}=`) || value.startsWith(`${key2}.`)) return true;
     }
   }
   return false;
@@ -43162,10 +43133,10 @@ function buildCoordinatorDelegatedCliLaunchOptions(input) {
   const cliArgs = Array.isArray(input.cliArgs) ? [...input.cliArgs] : [];
   const env = { ...input.env || {} };
   const envUnsets = new Set(DEFAULT_COORDINATOR_DELEGATED_ENV_UNSETS);
-  for (const key of input.isolation?.env?.unset || []) {
-    if (typeof key === "string" && key.trim()) envUnsets.add(key.trim());
+  for (const key2 of input.isolation?.env?.unset || []) {
+    if (typeof key2 === "string" && key2.trim()) envUnsets.add(key2.trim());
   }
-  for (const key of envUnsets) env[key] = "";
+  for (const key2 of envUnsets) env[key2] = "";
   for (const rule of input.isolation?.args || []) {
     if (!rule || typeof rule !== "object") continue;
     if (rule.mode === "empty_mcp_config") {
@@ -43178,9 +43149,9 @@ function buildCoordinatorDelegatedCliLaunchOptions(input) {
       continue;
     }
     if (rule.mode === "config_override") {
-      const key = String(rule.dedupeKey || rule.key || "").trim();
+      const key2 = String(rule.dedupeKey || rule.key || "").trim();
       const flag = String(rule.flag || "").trim();
-      if (!key || !flag || hasConfigOverride(cliArgs, key)) continue;
+      if (!key2 || !flag || hasConfigOverride(cliArgs, key2)) continue;
       cliArgs.unshift(flag, `${rule.key}=${rule.value}`);
     }
   }
@@ -43386,12 +43357,12 @@ var DaemonCliManager = class {
     }
     throw new Error(`No CLI provider found for '${cliType}'. Create a provider.js in providers/cli/${cliType}/`);
   }
-  startCliExitMonitor(key, cliType) {
+  startCliExitMonitor(key2, cliType) {
     const sessionRegistry = this.deps.getSessionRegistry?.() || null;
     const instanceManager = this.deps.getInstanceManager();
     const checkStopped = setInterval(() => {
       try {
-        const adapter = this.adapters.get(key);
+        const adapter = this.adapters.get(key2);
         if (!adapter) {
           clearInterval(checkStopped);
           return;
@@ -43400,12 +43371,12 @@ var DaemonCliManager = class {
         if (status?.status === "stopped" || status?.status === "error") {
           clearInterval(checkStopped);
           setTimeout(() => {
-            if (this.adapters.has(key)) {
-              this.adapters.delete(key);
-              this.deps.removeAgentTracking(key);
-              sessionRegistry?.unregisterByInstanceKey(key);
-              instanceManager?.removeInstance(key);
-              unregisterMeshCoordinator(key);
+            if (this.adapters.has(key2)) {
+              this.adapters.delete(key2);
+              this.deps.removeAgentTracking(key2);
+              sessionRegistry?.unregisterByInstanceKey(key2);
+              instanceManager?.removeInstance(key2);
+              unregisterMeshCoordinator(key2);
               LOG.info("CLI", `\u{1F9F9} Auto-cleaned ${status.status} CLI: ${cliType}`);
               this.deps.onStatusChange();
             }
@@ -43415,21 +43386,21 @@ var DaemonCliManager = class {
       }
     }, 3e3);
   }
-  async registerCliInstance(key, normalizedType, cliType, resolvedDir, cliArgs, provider, settings, attachExisting = false, options) {
+  async registerCliInstance(key2, normalizedType, cliType, resolvedDir, cliArgs, provider, settings, attachExisting = false, options) {
     const instanceManager = this.deps.getInstanceManager();
     const sessionRegistry = this.deps.getSessionRegistry?.() || null;
     if (!instanceManager) throw new Error("InstanceManager not available");
     const transportFactory = this.getTransportFactory(
-      key,
+      key2,
       normalizedType,
       resolvedDir,
       cliArgs,
       options?.providerSessionId,
       attachExisting
     );
-    const cliInstance = new CliProviderInstance(provider, resolvedDir, cliArgs, key, transportFactory, options);
+    const cliInstance = new CliProviderInstance(provider, resolvedDir, cliArgs, key2, transportFactory, options);
     try {
-      await instanceManager.addInstance(key, cliInstance, {
+      await instanceManager.addInstance(key2, cliInstance, {
         serverConn: this.deps.getServerConn(),
         settings,
         onPtyData: (data) => {
@@ -43441,8 +43412,8 @@ var DaemonCliManager = class {
         parentSessionId: null,
         providerType: normalizedType,
         transport: "pty",
-        adapterKey: key,
-        instanceKey: key,
+        adapterKey: key2,
+        instanceKey: key2,
         workspace: resolvedDir,
         // attachExisting === true means we're restoring an already-spawned
         // hosted runtime after a daemon restart, not starting a fresh PTY.
@@ -43458,10 +43429,10 @@ var DaemonCliManager = class {
       });
     } catch (spawnErr) {
       LOG.error("CLI", `[${cliType}] Spawn failed: ${spawnErr?.message}`);
-      instanceManager.removeInstance(key);
+      instanceManager.removeInstance(key2);
       throw new Error(`Failed to start ${provider.displayName || provider.name || cliType}: ${spawnErr?.message}`);
     }
-    this.adapters.set(key, cliInstance.getAdapter());
+    this.adapters.set(key2, cliInstance.getAdapter());
     const launchMeshNodeId = typeof settings?.meshNodeId === "string" ? settings.meshNodeId.trim() : "";
     const launchMeshNodeFor = typeof settings?.meshNodeFor === "string" ? settings.meshNodeFor.trim() : "";
     if (launchMeshNodeId || launchMeshNodeFor) {
@@ -43474,7 +43445,7 @@ var DaemonCliManager = class {
       } catch {
       }
     }
-    this.startCliExitMonitor(key, cliType);
+    this.startCliExitMonitor(key2, cliType);
   }
   // ─── Session start/management ──────────────────────────────
   async startSession(cliType, workingDir, cliArgs, initialModel, options) {
@@ -43491,11 +43462,11 @@ var DaemonCliManager = class {
 Enable and detect this provider from the Machine Providers page before starting a runtime.`
       );
     }
-    const key = crypto5.randomUUID();
+    const key2 = crypto5.randomUUID();
     {
       const coordinatorMeshId = options?.settingsOverride?.meshCoordinatorFor;
       if (typeof coordinatorMeshId === "string" && coordinatorMeshId.trim()) {
-        options = { ...options, extraEnv: { ...options?.extraEnv || {}, ADHDEV_COORDINATOR_SESSION_ID: key } };
+        options = { ...options, extraEnv: { ...options?.extraEnv || {}, ADHDEV_COORDINATOR_SESSION_ID: key2 } };
       }
     }
     const sessionRegistry = this.deps.getSessionRegistry?.() || null;
@@ -43515,7 +43486,7 @@ ${installInfo}`
       }
       console.log(colorize("cyan", `  \u{1F50C} Starting ACP agent: ${provider.name} (${provider.type}) in ${resolvedDir}`));
       const acpInstance = new AcpProviderInstance(resolvedProvider, resolvedDir, cliArgs);
-      await instanceManager2.addInstance(key, acpInstance, {
+      await instanceManager2.addInstance(key2, acpInstance, {
         settings: this.providerLoader.getSettings(normalizedType)
       });
       const sessionId = acpInstance.getInstanceId();
@@ -43524,11 +43495,11 @@ ${installInfo}`
         parentSessionId: null,
         providerType: normalizedType,
         transport: "acp",
-        adapterKey: key,
-        instanceKey: key,
+        adapterKey: key2,
+        instanceKey: key2,
         workspace: resolvedDir
       });
-      this.adapters.set(key, {
+      this.adapters.set(key2, {
         cliType: normalizedType,
         cliName: provider.name,
         workingDir: resolvedDir,
@@ -43536,7 +43507,7 @@ ${installInfo}`
         spawn: async () => {
         },
         shutdown: () => {
-          instanceManager2.removeInstance(key);
+          instanceManager2.removeInstance(key2);
         },
         sendMessage: async (text) => {
           const input = normalizeInputEnvelope(text);
@@ -43552,7 +43523,7 @@ ${installInfo}`
         },
         getPartialResponse: () => "",
         cancel: () => {
-          instanceManager2.removeInstance(key);
+          instanceManager2.removeInstance(key2);
         },
         isProcessing: () => false,
         isReady: () => true,
@@ -43606,7 +43577,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     if (provider && instanceManager) {
       const resolvedProvider = this.providerLoader.resolve(cliType, { version: cliInfo.version }) || provider;
       await this.registerCliInstance(
-        key,
+        key2,
         normalizedType,
         cliType,
         resolvedDir,
@@ -43636,7 +43607,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         cliType,
         resolvedDir,
         resolvedCliArgs,
-        key,
+        key2,
         sessionBinding.providerSessionId,
         false,
         options?.extraEnv
@@ -43656,9 +43627,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const status = adapter.getStatus?.();
         if (status?.status === "stopped" || status?.status === "error") {
           setTimeout(() => {
-            if (this.adapters.get(key) === adapter) {
-              this.adapters.delete(key);
-              this.deps.removeAgentTracking(key);
+            if (this.adapters.get(key2) === adapter) {
+              this.adapters.delete(key2);
+              this.deps.removeAgentTracking(key2);
               LOG.info("CLI", `\u{1F9F9} Auto-cleaned ${status.status} CLI: ${adapter.cliType}`);
               this.deps.onStatusChange();
             }
@@ -43667,10 +43638,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
       });
       if (typeof adapter.setOnPtyData === "function") {
         adapter.setOnPtyData((data) => {
-          this.deps.getP2p()?.broadcastSessionOutput(key, data);
+          this.deps.getP2p()?.broadcastSessionOutput(key2, data);
         });
       }
-      this.adapters.set(key, adapter);
+      this.adapters.set(key2, adapter);
       console.log(colorize("green", `  \u2713 CLI started: ${cliInfo.displayName} v${cliInfo.version || "unknown"} in ${resolvedDir}`));
     }
     this.persistRecentActivity({
@@ -43680,20 +43651,20 @@ Run 'adhdev doctor' for detailed diagnostics.`
       providerSessionId: sessionBinding.providerSessionId,
       workspace: resolvedDir,
       summaryMetadata: buildLegacyModelModeSummaryMetadata({ model: initialModel }),
-      sessionId: key,
+      sessionId: key2,
       title: provider?.displayName || provider?.name || normalizedType
     });
     this.deps.onStatusChange();
     return {
-      runtimeSessionId: key,
+      runtimeSessionId: key2,
       providerSessionId: sessionBinding.providerSessionId
     };
   }
-  async stopSession(key) {
-    return this.stopSessionWithMode(key, "hard");
+  async stopSession(key2) {
+    return this.stopSessionWithMode(key2, "hard");
   }
-  async stopSessionWithMode(key, mode) {
-    const adapter = this.adapters.get(key);
+  async stopSessionWithMode(key2, mode) {
+    const adapter = this.adapters.get(key2);
     if (adapter) {
       try {
         if (mode === "save" && typeof adapter.saveAndStop === "function") {
@@ -43704,21 +43675,21 @@ Run 'adhdev doctor' for detailed diagnostics.`
       } catch (e) {
         LOG.warn("CLI", `Shutdown error for ${adapter.cliType}: ${e?.message} (force-cleaning)`);
       }
-      this.adapters.delete(key);
-      this.deps.removeAgentTracking(key);
-      this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
-      this.deps.getInstanceManager()?.removeInstance(key);
-      unregisterMeshCoordinator(key);
+      this.adapters.delete(key2);
+      this.deps.removeAgentTracking(key2);
+      this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key2);
+      this.deps.getInstanceManager()?.removeInstance(key2);
+      unregisterMeshCoordinator(key2);
       LOG.info("CLI", `\u{1F6D1} Agent stopped: ${adapter.cliType} in ${adapter.workingDir}`);
       this.deps.onStatusChange();
     } else {
       const im = this.deps.getInstanceManager();
       if (im) {
-        this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
-        im.removeInstance(key);
-        this.deps.removeAgentTracking(key);
-        unregisterMeshCoordinator(key);
-        LOG.warn("CLI", `\u{1F9F9} Force-removed orphan entry: ${key}`);
+        this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key2);
+        im.removeInstance(key2);
+        this.deps.removeAgentTracking(key2);
+        unregisterMeshCoordinator(key2);
+        LOG.warn("CLI", `\u{1F9F9} Force-removed orphan entry: ${key2}`);
         this.deps.onStatusChange();
       }
     }
@@ -43746,8 +43717,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
     for (const r of sessions) {
       if (!r?.runtimeId || !r?.cliType || !r?.workspace) continue;
       restoredRuntimeIds.add(r.runtimeId);
-      const key = `${r.workspace}::${r.cliType}`;
-      workspaceTypeCounts.set(key, (workspaceTypeCounts.get(key) || 0) + 1);
+      const key2 = `${r.workspace}::${r.cliType}`;
+      workspaceTypeCounts.set(key2, (workspaceTypeCounts.get(key2) || 0) + 1);
     }
     for (const record of sessions) {
       if (!record?.runtimeId || !record?.cliType || !record?.workspace) continue;
@@ -44101,7 +44072,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           });
         }
         if (!found) throw new Error(`CLI agent not running: ${agentType}`);
-        const { adapter, key } = found;
+        const { adapter, key: key2 } = found;
         if (action === "send_chat") {
           let currentStatus = getEffectiveAgentSendStatus(adapter);
           if (currentStatus === "starting" && await waitForZeroMessageStartingLaunch(adapter)) {
@@ -44111,7 +44082,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           }
           const meshContext = args?.meshContext;
           if (meshContext && typeof meshContext === "object" && typeof meshContext.meshId === "string" && meshContext.meshId) {
-            const targetInstanceId = key;
+            const targetInstanceId = key2;
             try {
               this.deps.getInstanceManager()?.attachMeshAssignmentToInstance(targetInstanceId, {
                 meshId: meshContext.meshId,
@@ -44143,7 +44114,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           } else {
             await adapter.sendMessage(message);
           }
-          const targetInstance = this.deps.getInstanceManager()?.getInstance(key);
+          const targetInstance = this.deps.getInstanceManager()?.getInstance(key2);
           targetInstance?.recordAcknowledgedUserInput?.(input);
           return {
             success: true,
@@ -44155,7 +44126,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           if (typeof adapter.clearHistory === "function") adapter.clearHistory();
           return { success: true, cleared: true };
         } else if (action === "stop") {
-          await this.stopSession(key);
+          await this.stopSession(key2);
           return { success: true, stopped: true };
         }
         throw new Error(`Unknown action: ${action}`);
@@ -44427,9 +44398,9 @@ function validateProviderDefinition(raw) {
   } else if (!["ide", "extension", "cli", "acp"].includes(String(provider.category))) {
     errors.push(`Invalid category: ${String(provider.category)}`);
   }
-  for (const key of Object.keys(provider)) {
-    if (!KNOWN_PROVIDER_FIELDS.has(key)) {
-      warnings.push(`Unknown provider field: ${key}`);
+  for (const key2 of Object.keys(provider)) {
+    if (!KNOWN_PROVIDER_FIELDS.has(key2)) {
+      warnings.push(`Unknown provider field: ${key2}`);
     }
   }
   if (provider.disableUpstream !== void 0) {
@@ -44574,10 +44545,10 @@ function validateNativeHistory(raw, errors) {
     return;
   }
   const scriptConfig = scripts;
-  for (const key of ["readSession", "listSessions"]) {
-    const value = scriptConfig[key];
+  for (const key2 of ["readSession", "listSessions"]) {
+    const value = scriptConfig[key2];
     if (typeof value !== "string" || !value.trim()) {
-      errors.push(`nativeHistory.scripts.${key} must be a non-empty string`);
+      errors.push(`nativeHistory.scripts.${key2} must be a non-empty string`);
     }
   }
 }
@@ -44612,10 +44583,10 @@ function validateMeshCoordinatorMcpConfig(mcpConfig, errors) {
   if (format !== void 0 && !["claude_mcp_json", "hermes_config_yaml"].includes(String(format))) {
     errors.push("meshCoordinator.mcpConfig.format must be one of: claude_mcp_json, hermes_config_yaml");
   }
-  for (const key of ["path", "serverName", "configPathCommand", "instructions", "template"]) {
-    const value = config[key];
+  for (const key2 of ["path", "serverName", "configPathCommand", "instructions", "template"]) {
+    const value = config[key2];
     if (value !== void 0 && (typeof value !== "string" || !value.trim())) {
-      errors.push(`meshCoordinator.mcpConfig.${key} must be a non-empty string when provided`);
+      errors.push(`meshCoordinator.mcpConfig.${key2} must be a non-empty string when provided`);
     }
   }
   if (config.requiresRestart !== void 0 && typeof config.requiresRestart !== "boolean") {
@@ -44651,7 +44622,7 @@ function validateMeshCoordinatorDelegatedWorkerIsolation(raw, errors) {
       errors.push("meshCoordinator.delegatedWorkerIsolation.env must be an object");
     } else {
       const unset = env.unset;
-      if (unset !== void 0 && (!Array.isArray(unset) || unset.some((key) => typeof key !== "string" || !key.trim()))) {
+      if (unset !== void 0 && (!Array.isArray(unset) || unset.some((key2) => typeof key2 !== "string" || !key2.trim()))) {
         errors.push("meshCoordinator.delegatedWorkerIsolation.env.unset must be an array of non-empty strings");
       }
     }
@@ -44674,16 +44645,16 @@ function validateMeshCoordinatorDelegatedWorkerIsolation(raw, errors) {
       errors.push(`${prefix}.mode must be one of: empty_mcp_config, config_override`);
       continue;
     }
-    for (const key of mode === "empty_mcp_config" ? ["flag"] : ["flag", "key", "value"]) {
-      const value = item[key];
+    for (const key2 of mode === "empty_mcp_config" ? ["flag"] : ["flag", "key", "value"]) {
+      const value = item[key2];
       if (typeof value !== "string" || !value.trim()) {
-        errors.push(`${prefix}.${key} must be a non-empty string`);
+        errors.push(`${prefix}.${key2} must be a non-empty string`);
       }
     }
-    for (const key of ["strictFlag", "dedupeKey"]) {
-      const value = item[key];
+    for (const key2 of ["strictFlag", "dedupeKey"]) {
+      const value = item[key2];
       if (value !== void 0 && (typeof value !== "string" || !value.trim())) {
-        errors.push(`${prefix}.${key} must be a non-empty string when provided`);
+        errors.push(`${prefix}.${key2} must be a non-empty string when provided`);
       }
     }
   }
@@ -46906,9 +46877,9 @@ var ProviderLoader = class _ProviderLoader {
   reload() {
     this.log("Reloading all providers...");
     this.scriptsCache.clear();
-    for (const key of Object.keys(__require.cache)) {
-      if (key.includes("providers") && (key.endsWith(".js") || key.endsWith(".json"))) {
-        delete __require.cache[key];
+    for (const key2 of Object.keys(__require.cache)) {
+      if (key2.includes("providers") && (key2.endsWith(".js") || key2.endsWith(".json"))) {
+        delete __require.cache[key2];
       }
     }
     this.loadAll();
@@ -47216,7 +47187,7 @@ var ProviderLoader = class _ProviderLoader {
   */
   getPublicSettings(type) {
     const settings = this.getSettingsSchema(type);
-    return Object.entries(settings).filter(([, def]) => def.public === true).map(([key, def]) => ({ key, ...def }));
+    return Object.entries(settings).filter(([, def]) => def.public === true).map(([key2, def]) => ({ key: key2, ...def }));
   }
   /**
   * Get public settings schema for all providers
@@ -47232,23 +47203,23 @@ var ProviderLoader = class _ProviderLoader {
   /**
   * Resolved setting value for a provider (default + user override)
   */
-  getSettingValue(type, key) {
+  getSettingValue(type, key2) {
     const providerType = this.resolveAlias(type);
     const machineConfig = this.getMachineProviderConfig(providerType);
-    if (key === "enabled") {
+    if (key2 === "enabled") {
       return machineConfig.enabled === true;
     }
-    if (key === "executablePath") {
+    if (key2 === "executablePath") {
       return machineConfig.executable || "";
     }
-    if (key === "executableArgs") {
+    if (key2 === "executableArgs") {
       const args = machineConfig.args;
       return args ? args.map((arg) => /\s/.test(arg) ? JSON.stringify(arg) : arg).join(" ") : "";
     }
-    const schemaDef = this.getSettingsSchema(providerType)[key];
+    const schemaDef = this.getSettingsSchema(providerType)[key2];
     const defaultVal = schemaDef ? schemaDef.default : void 0;
     const config = this.readConfig();
-    const userVal = config?.providerSettings?.[providerType]?.[key];
+    const userVal = config?.providerSettings?.[providerType]?.[key2];
     return userVal !== void 0 ? userVal : defaultVal;
   }
   /**
@@ -47258,17 +47229,17 @@ var ProviderLoader = class _ProviderLoader {
     const providerType = this.resolveAlias(type);
     const settings = this.getSettingsSchema(providerType);
     const result = {};
-    for (const [key] of Object.entries(settings)) {
-      result[key] = this.getSettingValue(providerType, key);
+    for (const [key2] of Object.entries(settings)) {
+      result[key2] = this.getSettingValue(providerType, key2);
     }
     return result;
   }
   /**
   * Save provider setting value (writes to config.json)
   */
-  setSetting(type, key, value) {
+  setSetting(type, key2, value) {
     const providerType = this.resolveAlias(type);
-    const schemaDef = this.getSettingsSchema(providerType)[key];
+    const schemaDef = this.getSettingsSchema(providerType)[key2];
     if (!schemaDef) return false;
     if (!schemaDef.public) return false;
     if (schemaDef.type === "boolean" && typeof value !== "boolean") return false;
@@ -47279,13 +47250,13 @@ var ProviderLoader = class _ProviderLoader {
       if (schemaDef.max !== void 0 && value > schemaDef.max) return false;
     }
     if (schemaDef.type === "select" && schemaDef.options && !schemaDef.options.includes(value)) return false;
-    if (key === "enabled") {
+    if (key2 === "enabled") {
       return this.setMachineProviderEnabled(providerType, value);
     }
-    if (key === "executablePath") {
+    if (key2 === "executablePath") {
       return this.setMachineProviderConfig(providerType, { executable: value });
     }
-    if (key === "executableArgs") {
+    if (key2 === "executableArgs") {
       return this.setMachineProviderConfig(providerType, {
         args: value.trim() ? this.parseArgsSetting(value) : void 0
       });
@@ -47295,17 +47266,17 @@ var ProviderLoader = class _ProviderLoader {
     try {
       if (!config.providerSettings) config.providerSettings = {};
       if (!config.providerSettings[providerType]) config.providerSettings[providerType] = {};
-      config.providerSettings[providerType][key] = value;
+      config.providerSettings[providerType][key2] = value;
       this.writeConfig(config);
-      this.log(`Setting updated: ${providerType}.${key} = ${JSON.stringify(value)}`);
+      this.log(`Setting updated: ${providerType}.${key2} = ${JSON.stringify(value)}`);
       return true;
     } catch (e) {
       this.log(`Failed to save setting: ${e.message}`);
       return false;
     }
   }
-  getOptionalStringSetting(type, key) {
-    const value = this.getSettingValue(type, key);
+  getOptionalStringSetting(type, key2) {
+    const value = this.getSettingValue(type, key2);
     if (typeof value !== "string") return null;
     const trimmed = value.trim();
     return trimmed ? trimmed : null;
@@ -47485,7 +47456,7 @@ var ProviderLoader = class _ProviderLoader {
           try {
             let content = fs25.readFileSync(filePath, "utf-8");
             if (args[0] && typeof args[0] === "object") {
-              for (const [key, val] of Object.entries(args[0])) {
+              for (const [key2, val] of Object.entries(args[0])) {
                 let v = val;
                 if (typeof v === "string") {
                   if (!v.startsWith('"') && !v.startsWith("'") && !v.startsWith("`")) {
@@ -47494,7 +47465,7 @@ var ProviderLoader = class _ProviderLoader {
                 } else {
                   v = JSON.stringify(v);
                 }
-                const re = new RegExp(`\\$\\{\\s*${key}\\s*\\}`, "g");
+                const re = new RegExp(`\\$\\{\\s*${key2}\\s*\\}`, "g");
                 content = content.replace(re, String(v));
               }
             } else if (typeof args[0] === "string") {
@@ -48283,6 +48254,21 @@ init_mesh_host_ownership();
 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 {
@@ -48373,7 +48359,8 @@ var meshCrudHandlers = {
   // 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" };
@@ -48744,7 +48731,7 @@ var meshCrudHandlers = {
         }
       };
       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,
@@ -48778,12 +48765,25 @@ var meshCrudHandlers = {
                   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) {
@@ -49217,9 +49217,20 @@ var meshQueueHandlers = {
         targetNodeId: typeof args?.targetNodeId === "string" ? args.targetNodeId.trim() : void 0,
         targetSessionId: typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : void 0,
         clearTargetNode: args?.clearTargetNode === true,
-        clearTargetSession: args?.clearTargetSession !== false
+        clearTargetSession: args?.clearTargetSession !== false,
+        // CANON-IDENTITY: an in-flight (actively-generating) task is refused by
+        // default to avoid a duplicate second dispatch; an explicit operator
+        // force overrides that guard (and the retry cap).
+        force: args?.force === true
       });
       if (!task) return { success: false, error: `Queue task '${taskId}' not found` };
+      if (task.status === "assigned" && args?.force !== true) {
+        return {
+          success: false,
+          error: `Task '${taskId}' is actively dispatched/generating; requeue refused to avoid a duplicate second dispatch. Pass force:true to override, or cancel and re-enqueue.`,
+          task
+        };
+      }
       return { success: true, task };
     } catch (e) {
       return { success: false, error: e.message };
@@ -50750,15 +50761,15 @@ var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
 function maskArgs(args) {
   if (!args || typeof args !== "object") return void 0;
   const masked = {};
-  for (const [key, value] of Object.entries(args)) {
-    if (SENSITIVE_KEYS.has(key)) {
-      masked[key] = typeof value === "string" ? `[${value.length} chars]` : "[masked]";
-    } else if (key.startsWith("_")) {
-      masked[key] = value;
+  for (const [key2, value] of Object.entries(args)) {
+    if (SENSITIVE_KEYS.has(key2)) {
+      masked[key2] = typeof value === "string" ? `[${value.length} chars]` : "[masked]";
+    } else if (key2.startsWith("_")) {
+      masked[key2] = value;
     } else if (typeof value === "object" && value !== null) {
-      masked[key] = Array.isArray(value) ? `[Array(${value.length})]` : `[Object]`;
+      masked[key2] = Array.isArray(value) ? `[Array(${value.length})]` : `[Object]`;
     } else {
-      masked[key] = value;
+      masked[key2] = value;
     }
   }
   return masked;
@@ -51855,23 +51866,23 @@ var MeshGitProbeCache = class {
    * neither gate is satisfied.
    */
   async probe(daemonId, workspace, probe) {
-    const key = this.key(daemonId, workspace);
-    const cached3 = this.recent.get(key);
+    const key2 = this.key(daemonId, workspace);
+    const cached3 = this.recent.get(key2);
     if (cached3 && this.now() - cached3.at < this.reuseMs) {
       return cached3.value;
     }
-    const existing = this.inflight.get(key);
+    const existing = this.inflight.get(key2);
     if (existing) return existing;
     const pending = (async () => {
       const result = await probe();
-      if (result) this.recent.set(key, { at: this.now(), value: result });
+      if (result) this.recent.set(key2, { at: this.now(), value: result });
       return result;
     })();
-    this.inflight.set(key, pending);
+    this.inflight.set(key2, pending);
     try {
       return await pending;
     } finally {
-      if (this.inflight.get(key) === pending) this.inflight.delete(key);
+      if (this.inflight.get(key2) === pending) this.inflight.delete(key2);
     }
   }
 };
@@ -54569,8 +54580,8 @@ var DaemonCommandRouter = class {
           if (source !== "refine_mesh_node_async_job") continue;
           const jobId = e.payload?.refineJob?.jobId;
           if (!jobId || terminal.has(`${e.nodeId}:${jobId}`)) continue;
-          const key = this.buildRefineJobKey(meshId, e.nodeId);
-          if (this.runningRefineJobs.has(key)) continue;
+          const key2 = this.buildRefineJobKey(meshId, e.nodeId);
+          if (this.runningRefineJobs.has(key2)) continue;
           const coordinatorDaemonId = e.payload?.refineJob?.targetCoordinatorDaemonId;
           LOG.info("Mesh", `[Refinery] Auto-resuming interrupted refine job for node ${e.nodeId} (jobId=${jobId})`);
           void this.startMeshRefineJob(meshId, e.nodeId, {
@@ -55653,7 +55664,7 @@ ${hintLines.join("\n")}` : "",
     }
   }
   async finishMeshRefineBatchJob(handle, orderedNodes, ordering, args) {
-    const key = this.buildRefineBatchJobKey(handle.meshId);
+    const key2 = this.buildRefineBatchJobKey(handle.meshId);
     let result;
     try {
       result = await this.runMeshRefineBatchConvergence(handle.meshId, orderedNodes, ordering, args);
@@ -55685,8 +55696,8 @@ ${hintLines.join("\n")}` : "",
       coordinatorDaemonId: handle.targetCoordinatorDaemonId
     });
     const terminal = { ...terminalHandle, result: normalizedResult };
-    this.terminalRefineBatchJobs.set(key, terminal);
-    this.runningRefineBatchJobs.delete(key);
+    this.terminalRefineBatchJobs.set(key2, terminal);
+    this.runningRefineBatchJobs.delete(key2);
     this.invalidateAggregateMeshStatus(handle.meshId);
     await this.appendRefineBatchJobLedger(isTerminalSuccess ? "task_completed" : "task_failed", terminalHandle, normalizedResult);
     this.queueRefineBatchJobEvent(isTerminalSuccess ? "refine:completed" : "refine:failed", terminalHandle, normalizedResult);
@@ -55710,8 +55721,8 @@ ${hintLines.join("\n")}` : "",
     if (nodeIds.length === 0) {
       return { ...planRecord, success: true, batch: true, dryRun: false, async: false };
     }
-    const key = this.buildRefineBatchJobKey(meshId);
-    const running = this.runningRefineBatchJobs.get(key);
+    const key2 = this.buildRefineBatchJobKey(meshId);
+    const running = this.runningRefineBatchJobs.get(key2);
     if (running) return { ...running, duplicate: true };
     const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
     const mesh = meshRecord?.mesh;
@@ -55726,7 +55737,7 @@ ${hintLines.join("\n")}` : "",
     };
     const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : this.deps.statusInstanceId || void 0;
     const handle = this.buildRefineBatchJobHandle({ meshId, nodeIds, order, coordinatorDaemonId });
-    this.runningRefineBatchJobs.set(key, handle);
+    this.runningRefineBatchJobs.set(key2, handle);
     await this.appendRefineBatchJobLedger("task_dispatched", handle);
     this.queueRefineBatchJobEvent("refine:accepted", handle);
     setImmediate(() => {
@@ -55741,7 +55752,7 @@ ${hintLines.join("\n")}` : "",
     };
   }
   async finishMeshRefineJob(handle, args) {
-    const key = this.buildRefineJobKey(handle.meshId, handle.targetNodeId);
+    const key2 = this.buildRefineJobKey(handle.meshId, handle.targetNodeId);
     let result;
     try {
       result = await this.executeMeshRefineNodeSynchronously(handle.meshId, handle.targetNodeId, args);
@@ -55809,17 +55820,17 @@ ${hintLines.join("\n")}` : "",
       coordinatorDaemonId: handle.targetCoordinatorDaemonId
     });
     const terminal = { ...terminalHandle, result: normalizedResult };
-    this.terminalRefineJobs.set(key, terminal);
-    this.runningRefineJobs.delete(key);
+    this.terminalRefineJobs.set(key2, terminal);
+    this.runningRefineJobs.delete(key2);
     this.invalidateAggregateMeshStatus(handle.meshId);
     await this.appendRefineJobLedger(isTerminalSuccess ? "task_completed" : "task_failed", terminalHandle, normalizedResult);
     this.queueRefineJobEvent(isTerminalSuccess ? "refine:completed" : "refine:failed", terminalHandle, normalizedResult);
   }
   async startMeshRefineJob(meshId, nodeId, args) {
-    const key = this.buildRefineJobKey(meshId, nodeId);
-    const running = this.runningRefineJobs.get(key);
+    const key2 = this.buildRefineJobKey(meshId, nodeId);
+    const running = this.runningRefineJobs.get(key2);
     if (running) return { ...running, duplicate: true };
-    const terminal = this.terminalRefineJobs.get(key);
+    const terminal = this.terminalRefineJobs.get(key2);
     const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
     const mesh = meshRecord?.mesh;
     const node = mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
@@ -55827,7 +55838,7 @@ ${hintLines.join("\n")}` : "",
     if (!node.isLocalWorktree || !node.workspace) return { success: false, error: `Refinery requires a local worktree node` };
     const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : this.deps.statusInstanceId || void 0;
     const handle = this.buildRefineJobHandle({ meshId, nodeId, node, retryOfJobId: terminal?.jobId, coordinatorDaemonId });
-    this.runningRefineJobs.set(key, handle);
+    this.runningRefineJobs.set(key2, handle);
     await this.appendRefineJobLedger("task_dispatched", handle);
     this.queueRefineJobEvent("refine:accepted", handle);
     setImmediate(() => {
@@ -55883,27 +55894,27 @@ ${hintLines.join("\n")}` : "",
    */
   async stopIde(ideType, killProcess = false) {
     const cdpKeysToRemove = [];
-    for (const key of this.deps.cdpManagers.keys()) {
-      if (key === ideType || key.startsWith(`${ideType}_`)) {
-        cdpKeysToRemove.push(key);
+    for (const key2 of this.deps.cdpManagers.keys()) {
+      if (key2 === ideType || key2.startsWith(`${ideType}_`)) {
+        cdpKeysToRemove.push(key2);
       }
     }
-    for (const key of cdpKeysToRemove) {
-      const cdp = this.deps.cdpManagers.get(key);
+    for (const key2 of cdpKeysToRemove) {
+      const cdp = this.deps.cdpManagers.get(key2);
       if (cdp) {
         try {
           cdp.disconnect();
         } catch {
         }
-        this.deps.cdpManagers.delete(key);
-        this.deps.sessionRegistry.unregisterByManagerKey(key);
-        LOG.info("StopIDE", `CDP disconnected: ${key}`);
+        this.deps.cdpManagers.delete(key2);
+        this.deps.sessionRegistry.unregisterByManagerKey(key2);
+        LOG.info("StopIDE", `CDP disconnected: ${key2}`);
       }
     }
     const keysToRemove = [];
-    for (const key of this.deps.instanceManager.listInstanceIds()) {
-      if (key === `ide:${ideType}` || typeof key === "string" && key.startsWith(`ide:${ideType}_`)) {
-        keysToRemove.push(key);
+    for (const key2 of this.deps.instanceManager.listInstanceIds()) {
+      if (key2 === `ide:${ideType}` || typeof key2 === "string" && key2.startsWith(`ide:${ideType}_`)) {
+        keysToRemove.push(key2);
       }
     }
     for (const instanceKey of keysToRemove) {
@@ -60596,9 +60607,9 @@ async function handleAutoImplement(ctx, type, req, res) {
       }
       if (Date.now() - lastApprovalTime < 2e3) return;
       if (approvalPatterns.some((p) => p.test(approvalBuffer))) {
-        const key = approvalKeys[1] || approvalKeys[0] || "a\r";
-        writeFn(key);
-        ctx.log(`Auto-Implement auto-approved prompt! Sending: ${JSON.stringify(key)}`);
+        const key2 = approvalKeys[1] || approvalKeys[0] || "a\r";
+        writeFn(key2);
+        ctx.log(`Auto-Implement auto-approved prompt! Sending: ${JSON.stringify(key2)}`);
         sendAutoImplSSE(ctx, { event: "output", data: { chunk: `
 [\u{1F916} ADHDev Auto-Approve] CLI Action Approved
 `, stream: "stdout" } });
@@ -61850,8 +61861,8 @@ var DevServer = class _DevServer {
       category: p.category
     }));
     const cdpStatus = {};
-    for (const [key, cdp] of this.cdpManagers.entries()) {
-      cdpStatus[key] = { connected: cdp.isConnected };
+    for (const [key2, cdp] of this.cdpManagers.entries()) {
+      cdpStatus[key2] = { connected: cdp.isConnected };
     }
     this.json(res, 200, {
       devMode: true,
@@ -62171,16 +62182,16 @@ var DevServer = class _DevServer {
       errors.push(...validation.errors);
       warnings.push(...validation.warnings);
       if (config.settings) {
-        for (const [key, val] of Object.entries(config.settings)) {
+        for (const [key2, val] of Object.entries(config.settings)) {
           const s2 = val;
-          if (!s2.type) errors.push(`settings.${key}: missing type`);
+          if (!s2.type) errors.push(`settings.${key2}: missing type`);
           else if (!["boolean", "number", "string", "select"].includes(s2.type))
-            errors.push(`settings.${key}: invalid type '${s2.type}'`);
-          if (s2.default === void 0) warnings.push(`settings.${key}: no default value`);
+            errors.push(`settings.${key2}: invalid type '${s2.type}'`);
+          if (s2.default === void 0) warnings.push(`settings.${key2}: no default value`);
           if (s2.type === "number" && s2.min !== void 0 && s2.max !== void 0 && s2.min > s2.max)
-            errors.push(`settings.${key}: min (${s2.min}) > max (${s2.max})`);
+            errors.push(`settings.${key2}: min (${s2.min}) > max (${s2.max})`);
           if (s2.type === "select" && (!s2.options || !Array.isArray(s2.options) || s2.options.length === 0))
-            errors.push(`settings.${key}: select type requires options[]`);
+            errors.push(`settings.${key2}: select type requires options[]`);
         }
       }
       if (config.cdpPorts && Array.isArray(config.cdpPorts)) {
@@ -62968,21 +62979,21 @@ function isLowercaseLetter(value) {
 function encodeControlLetter(letter) {
   return String.fromCharCode(letter.charCodeAt(0) - 96);
 }
-function encodeShiftedKey(key) {
-  if (isLowercaseLetter(key)) return key.toUpperCase();
-  if (key.startsWith("ctrl+") && isLowercaseLetter(key.slice(5))) {
-    return encodeControlLetter(key.slice(5));
+function encodeShiftedKey(key2) {
+  if (isLowercaseLetter(key2)) return key2.toUpperCase();
+  if (key2.startsWith("ctrl+") && isLowercaseLetter(key2.slice(5))) {
+    return encodeControlLetter(key2.slice(5));
   }
-  if (key.startsWith("alt+") && isLowercaseLetter(key.slice(4))) {
-    return `\x1B${key.slice(4).toUpperCase()}`;
+  if (key2.startsWith("alt+") && isLowercaseLetter(key2.slice(4))) {
+    return `\x1B${key2.slice(4).toUpperCase()}`;
   }
-  if (key === "tab") return "\x1B[Z";
-  if (key in SHIFTED_CSI_KEYS) return SHIFTED_CSI_KEYS[key];
-  if (key in BASE_KEY_SEQUENCES) return BASE_KEY_SEQUENCES[key];
-  throw new Error(`Unsupported named key: shift+${key}`);
+  if (key2 === "tab") return "\x1B[Z";
+  if (key2 in SHIFTED_CSI_KEYS) return SHIFTED_CSI_KEYS[key2];
+  if (key2 in BASE_KEY_SEQUENCES) return BASE_KEY_SEQUENCES[key2];
+  throw new Error(`Unsupported named key: shift+${key2}`);
 }
-function namedKeyToAnsi(key) {
-  const normalized = String(key || "").trim().toLowerCase();
+function namedKeyToAnsi(key2) {
+  const normalized = String(key2 || "").trim().toLowerCase();
   if (normalized in BASE_KEY_SEQUENCES) return BASE_KEY_SEQUENCES[normalized];
   if (normalized.startsWith("ctrl+") && isLowercaseLetter(normalized.slice(5))) {
     return encodeControlLetter(normalized.slice(5));
@@ -62991,7 +63002,7 @@ function namedKeyToAnsi(key) {
     return `\x1B${normalized.slice(4)}`;
   }
   if (normalized.startsWith("shift+")) return encodeShiftedKey(normalized.slice(6));
-  throw new Error(`Unsupported named key: ${key}`);
+  throw new Error(`Unsupported named key: ${key2}`);
 }
 function namedKeysToAnsi(keys) {
   if (!Array.isArray(keys)) throw new Error("keys must be an array");
@@ -63472,19 +63483,19 @@ var SessionRegistry = class {
     if (!ids) return [];
     return [...ids].map((id) => this.bySessionId.get(id)).filter(Boolean);
   }
-  addIndex(index, key, sessionId) {
-    let set = index.get(key);
+  addIndex(index, key2, sessionId) {
+    let set = index.get(key2);
     if (!set) {
       set = /* @__PURE__ */ new Set();
-      index.set(key, set);
+      index.set(key2, set);
     }
     set.add(sessionId);
   }
-  removeIndex(index, key, sessionId) {
-    const set = index.get(key);
+  removeIndex(index, key2, sessionId) {
+    const set = index.get(key2);
     if (!set) return;
     set.delete(sessionId);
-    if (set.size === 0) index.delete(key);
+    if (set.size === 0) index.delete(key2);
   }
 };
 
@@ -64144,6 +64155,7 @@ export {
   buildToolChatMessage,
   buildUserChatMessage,
   cancelTask,
+  canonicalDaemonId,
   claimNextTask,
   classifyChatMessageVisibility,
   classifyHotChatSessionsForSubscriptionFlush,
@@ -64272,6 +64284,7 @@ export {
   loadMeshCoordinatorRegistry,
   loadMeshRefineConfig,
   loadMeshWorktreeBootstrapConfig,
+  loadRepoSettings,
   loadState,
   logCommand,
   machineCoreFromDaemonId,