@adhdev/daemon-core 1.0.18-rc.17 → 1.0.18-rc.19

package/dist/index.js

@@ -184,7 +184,7 @@ function mergeAndNormalizePolicy(base, patch) {
   }
   return policy;
 }
-function resolveDelegatedWorkerAutoApprove(meshPolicy, nodePolicy, provider) {
+function resolveDelegatedWorkerAutoApprove(meshPolicy, nodePolicy, provider, repoConfig, providerType) {
   let enabled = true;
   if (typeof nodePolicy?.delegatedWorkerAutoApprove === "boolean") {
     enabled = nodePolicy.delegatedWorkerAutoApprove;
@@ -194,14 +194,17 @@ function resolveDelegatedWorkerAutoApprove(meshPolicy, nodePolicy, provider) {
   if (!enabled) return false;
   const modes = provider?.autoApproveModes;
   if (!modes) return true;
-  const defaultMode = modes.modes.find((mode) => mode.id === modes.default);
-  if (!defaultMode || defaultMode.strategy === "post-boot-command") return false;
+  const requestedModeRaw = typeof providerType === "string" ? repoConfig?.providerDefaults?.autoApproveModes?.[providerType.trim()] : void 0;
+  const requestedModeId = typeof requestedModeRaw === "string" && requestedModeRaw.trim() ? requestedModeRaw.trim() : "";
+  const requestedMode = requestedModeId ? modes.modes.find((mode) => mode.id === requestedModeId) : void 0;
+  const selectedMode = requestedMode ?? modes.modes.find((mode) => mode.id === modes.default);
+  if (!selectedMode || selectedMode.strategy === "post-boot-command") return false;
   const dangerousAllowed = resolveDelegatedWorkerDangerousModeAllow(meshPolicy, nodePolicy);
-  if (deriveAutoApproveModeRisk(defaultMode) === "dangerous" && !dangerousAllowed) {
+  if (deriveAutoApproveModeRisk(selectedMode) === "dangerous" && !dangerousAllowed) {
     const ptyFallback = modes.modes.find((mode) => mode.strategy === "pty-parse-default" && deriveAutoApproveModeRisk(mode) !== "dangerous");
     return ptyFallback?.id || false;
   }
-  return defaultMode.id;
+  return selectedMode.id;
 }
 function resolveDelegatedWorkerDangerousModeAllow(meshPolicy, nodePolicy) {
   if (typeof nodePolicy?.delegatedWorkerDangerousModeAllow === "boolean") {
@@ -209,8 +212,8 @@ function resolveDelegatedWorkerDangerousModeAllow(meshPolicy, nodePolicy) {
   }
   return meshPolicy?.delegatedWorkerDangerousModeAllow === true;
 }
-function delegatedWorkerAutoApproveSettings(meshPolicy, nodePolicy, provider) {
-  const resolved = resolveDelegatedWorkerAutoApprove(meshPolicy, nodePolicy, provider);
+function delegatedWorkerAutoApproveSettings(meshPolicy, nodePolicy, provider, repoConfig, providerType) {
+  const resolved = resolveDelegatedWorkerAutoApprove(meshPolicy, nodePolicy, provider, repoConfig, providerType);
   const delegatedWorkerDangerousModeAllow = resolveDelegatedWorkerDangerousModeAllow(meshPolicy, nodePolicy);
   return typeof resolved === "string" ? { autoApprove: void 0, autoApproveMode: resolved, delegatedWorkerDangerousModeAllow } : { autoApprove: resolved, autoApproveMode: void 0, delegatedWorkerDangerousModeAllow };
 }
@@ -310,6 +313,267 @@ var init_repo_mesh_types = __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,
+  MESH_JSON_PROVIDER_DEFAULTS_EXAMPLE: () => MESH_JSON_PROVIDER_DEFAULTS_EXAMPLE,
+  applyRepoMeshConfig: () => applyRepoMeshConfig,
+  buildMeshJsonConfigScaffold: () => buildMeshJsonConfigScaffold,
+  loadRepoMeshJsonConfig: () => loadRepoMeshJsonConfig,
+  mergeEffectiveCoordinatorConfig: () => mergeEffectiveCoordinatorConfig,
+  mergeEffectiveOperatingNotes: () => mergeEffectiveOperatingNotes,
+  normalizeRepoMeshDeclarativeConfig: () => normalizeRepoMeshDeclarativeConfig,
+  serializeMeshJsonConfigScaffold: () => serializeMeshJsonConfigScaffold
+});
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function parseConfigText(path46, text) {
+  if (/\.json$/i.test(path46)) return JSON.parse(text);
+  return yaml.load(text);
+}
+function normalizeOperatingNote(value) {
+  if (!isRecord(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 } : {},
+    // Operating-notes lifecycle: a repo-declared note may pin itself or set an
+    // explicit expiry, same as a runtime-recorded one. Phase 2 (b)/(c): it may
+    // also declare supersedes/subjectKey to retire an earlier note or group
+    // same-subject notes for folding.
+    ...value.pinned === true ? { pinned: true } : {},
+    ...typeof value.expiresAt === "string" ? { expiresAt: value.expiresAt } : {},
+    ...typeof value.supersedes === "string" ? { supersedes: value.supersedes } : {},
+    ...typeof value.subjectKey === "string" ? { subjectKey: value.subjectKey } : {}
+  };
+}
+function normalizeRepoMeshDeclarativeConfig(parsed) {
+  const errors = [];
+  if (!isRecord(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 (isRecord(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 (isRecord(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");
+    }
+  }
+  if (parsed.providerDefaults !== void 0) {
+    if (isRecord(parsed.providerDefaults)) {
+      const pd = {};
+      const rawModes = parsed.providerDefaults.autoApproveModes;
+      if (rawModes !== void 0) {
+        if (isRecord(rawModes)) {
+          const modes = {};
+          for (const [providerType, modeId] of Object.entries(rawModes)) {
+            const type = typeof providerType === "string" ? providerType.trim() : "";
+            const id = typeof modeId === "string" ? modeId.trim() : "";
+            if (type && id) modes[type] = id;
+          }
+          if (Object.keys(modes).length) pd.autoApproveModes = modes;
+        } else {
+          errors.push("providerDefaults.autoApproveModes must be an object when provided");
+        }
+      }
+      if (Object.keys(pd).length) config.providerDefaults = pd;
+    } else {
+      errors.push("providerDefaults 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 = (0, import_path.join)(base, relative5);
+      if (!(0, import_fs.existsSync)(configPath)) continue;
+      try {
+        const parsed = parseConfigText(configPath, (0, import_fs.readFileSync)(configPath, "utf-8"));
+        const result = normalizeRepoMeshDeclarativeConfig(parsed);
+        if (!result.valid || !result.config) {
+          return { source: relative5, sourceType: "invalid", path: configPath, error: result.errors.join("; ") };
+        }
+        return { config: result.config, source: relative5, sourceType: "repo_file", path: configPath };
+      } catch (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 import_fs, import_path, yaml, MESH_JSON_CONFIG_LOCATIONS, MESH_JSON_CONFIG_SCHEMA, MESH_JSON_PROVIDER_DEFAULTS_EXAMPLE;
+var init_mesh_json_config = __esm({
+  "src/config/mesh-json-config.ts"() {
+    "use strict";
+    import_fs = require("fs");
+    import_path = require("path");
+    yaml = __toESM(require("js-yaml"));
+    MESH_JSON_CONFIG_LOCATIONS = [
+      ".adhdev/mesh.json",
+      ".adhdev/mesh.yaml",
+      ".adhdev/mesh.yml"
+    ];
+    MESH_JSON_CONFIG_SCHEMA = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      title: "ADHDev Repo Mesh Declarative Config",
+      type: "object",
+      additionalProperties: false,
+      required: ["version"],
+      properties: {
+        version: { const: 1 },
+        coordinator: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            systemPromptOverride: { type: "string" },
+            systemPromptAppend: { type: "string" },
+            maxPromptChars: { type: "number", minimum: 1 }
+          }
+        },
+        operatingNotes: {
+          type: "array",
+          maxItems: 200,
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["text"],
+            properties: {
+              text: { type: "string", minLength: 1 },
+              category: { enum: ["provider_quirk", "pattern_to_avoid", "recovery_lesson"] },
+              createdAt: { type: "string" },
+              sourceCoordinator: { type: "string" }
+            }
+          }
+        },
+        limits: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            maxNoteChars: { type: "number", minimum: 1 },
+            maxNotes: { type: "number", minimum: 1 }
+          }
+        },
+        providerDefaults: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            // providerType → requested auto-approve mode ID. Mode IDs are
+            // validated against the live provider spec at resolve time; an
+            // unknown ID is ignored (provider default is used), so the schema
+            // only constrains the shape (string→string), not the ID values.
+            autoApproveModes: {
+              type: "object",
+              additionalProperties: { type: "string" }
+            }
+          }
+        }
+      }
+    };
+    MESH_JSON_PROVIDER_DEFAULTS_EXAMPLE = {
+      autoApproveModes: {
+        "claude-cli": "accept-edits",
+        "codex-cli": "auto"
+      }
+    };
+  }
+});
+
 // src/git/git-executor.ts
 var git_executor_exports = {};
 __export(git_executor_exports, {
@@ -526,10 +790,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "eeb3e1474488eb5543c443270208f3ca8958a86a" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "eeb3e147" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "1.0.18-rc.17" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-23T03:30:50.962Z" : void 0);
+  const commit = readInjected(true ? "957753ce64d49cf4222cb2675d7d919871d3f009" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "957753ce" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "1.0.18-rc.19" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-23T07:07:10.469Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -541,14 +805,14 @@ var init_build_info = __esm({
 });
 
 // src/git/change-impact-config.ts
-function isRecord(value) {
+function isRecord2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function isStringArray(value) {
   return Array.isArray(value) && value.every((v) => typeof v === "string" && v.length > 0);
 }
 function validateTarget(value, key2, errors) {
-  if (!isRecord(value)) {
+  if (!isRecord2(value)) {
     errors.push(`impactTargets.${key2} must be an object`);
     return void 0;
   }
@@ -564,7 +828,7 @@ function validateTarget(value, key2, errors) {
 }
 function validateChangeImpactConfig(raw, source = "inline") {
   const errors = [];
-  if (!isRecord(raw)) {
+  if (!isRecord2(raw)) {
     return { valid: false, errors: [`${source}: config must be an object`] };
   }
   const config = {};
@@ -581,7 +845,7 @@ function validateChangeImpactConfig(raw, source = "inline") {
     else errors.push("nonRuntimeRootFilePatterns must be an array of non-empty strings");
   }
   if (raw.impactTargets !== void 0) {
-    if (!isRecord(raw.impactTargets)) {
+    if (!isRecord2(raw.impactTargets)) {
       errors.push("impactTargets must be an object");
     } else {
       const targets = {};
@@ -603,23 +867,23 @@ function validateChangeImpactConfig(raw, source = "inline") {
   }
   return { valid: errors.length === 0, errors, config: errors.length === 0 ? config : void 0 };
 }
-function parseConfigText(path46, text) {
+function parseConfigText2(path46, text) {
   if (/\.json$/i.test(path46)) return JSON.parse(text);
-  return yaml.load(text);
+  return yaml2.load(text);
 }
 function loadChangeImpactConfig(repoRoot) {
   for (const relative5 of CHANGE_IMPACT_CONFIG_LOCATIONS) {
-    const configPath = (0, import_path.join)(repoRoot, relative5);
-    if (!(0, import_fs.existsSync)(configPath)) continue;
+    const configPath = (0, import_path2.join)(repoRoot, relative5);
+    if (!(0, import_fs2.existsSync)(configPath)) continue;
     try {
-      const text = (0, import_fs.readFileSync)(configPath, "utf-8");
+      const text = (0, import_fs2.readFileSync)(configPath, "utf-8");
       let mtimeMs = 0;
       try {
-        mtimeMs = (0, import_fs.statSync)(configPath).mtimeMs;
+        mtimeMs = (0, import_fs2.statSync)(configPath).mtimeMs;
       } catch {
         mtimeMs = text.length;
       }
-      const parsed = parseConfigText(configPath, text);
+      const parsed = parseConfigText2(configPath, text);
       const validation = validateChangeImpactConfig(parsed, relative5);
       if (!validation.valid) {
         return {
@@ -678,7 +942,7 @@ function globToRegExp(pattern) {
 }
 function listPackageDirs(packagesRoot) {
   try {
-    return (0, import_fs.readdirSync)(packagesRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name);
+    return (0, import_fs2.readdirSync)(packagesRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => entry.name);
   } catch {
     return [];
   }
@@ -688,10 +952,10 @@ function suggestChangeImpactConfig(repoRoot) {
   const daemon = /* @__PURE__ */ new Set();
   const web = /* @__PURE__ */ new Set();
   const unclassified = [];
-  const roots = ["packages", (0, import_path.join)("oss", "packages")];
+  const roots = ["packages", (0, import_path2.join)("oss", "packages")];
   for (const rel of roots) {
-    const packagesRoot = (0, import_path.join)(repoRoot, rel);
-    if (!(0, import_fs.existsSync)(packagesRoot)) continue;
+    const packagesRoot = (0, import_path2.join)(repoRoot, rel);
+    if (!(0, import_fs2.existsSync)(packagesRoot)) continue;
     for (const name of listPackageDirs(packagesRoot)) {
       if (/(^web[-.]|[-.]web$)/i.test(name) || /dashboard|frontend|ui$/i.test(name)) {
         web.add(name);
@@ -733,13 +997,13 @@ function suggestChangeImpactConfig(repoRoot) {
     discoveredPackages: { daemon: daemonRuntimePackages, web: webOnlyPackages, unclassified }
   };
 }
-var import_fs, import_path, yaml, CHANGE_IMPACT_CONFIG_LOCATIONS, CHANGE_IMPACT_CONFIG_SCHEMA;
+var import_fs2, import_path2, yaml2, CHANGE_IMPACT_CONFIG_LOCATIONS, CHANGE_IMPACT_CONFIG_SCHEMA;
 var init_change_impact_config = __esm({
   "src/git/change-impact-config.ts"() {
     "use strict";
-    import_fs = require("fs");
-    import_path = require("path");
-    yaml = __toESM(require("js-yaml"));
+    import_fs2 = require("fs");
+    import_path2 = require("path");
+    yaml2 = __toESM(require("js-yaml"));
     CHANGE_IMPACT_CONFIG_LOCATIONS = [
       ".adhdev/change-impact.json",
       ".adhdev/change-impact.yaml",
@@ -1824,25 +2088,25 @@ function ensureMachineId(config) {
 }
 function getConfigDir() {
   const override = process.env.ADHDEV_CONFIG_DIR;
-  const dir = override && override.trim() ? override.trim() : (0, import_path2.join)((0, import_os.homedir)(), ".adhdev");
-  if (!(0, import_fs2.existsSync)(dir)) {
-    (0, import_fs2.mkdirSync)(dir, { recursive: true });
+  const dir = override && override.trim() ? override.trim() : (0, import_path3.join)((0, import_os.homedir)(), ".adhdev");
+  if (!(0, import_fs3.existsSync)(dir)) {
+    (0, import_fs3.mkdirSync)(dir, { recursive: true });
   }
   return dir;
 }
 function getDaemonDataDir() {
-  const dir = (0, import_path2.join)(getConfigDir(), "daemon");
-  if (!(0, import_fs2.existsSync)(dir)) {
-    (0, import_fs2.mkdirSync)(dir, { recursive: true });
+  const dir = (0, import_path3.join)(getConfigDir(), "daemon");
+  if (!(0, import_fs3.existsSync)(dir)) {
+    (0, import_fs3.mkdirSync)(dir, { recursive: true });
   }
   return dir;
 }
 function getConfigPath() {
-  return (0, import_path2.join)(getConfigDir(), "config.json");
+  return (0, import_path3.join)(getConfigDir(), "config.json");
 }
 function migrateStateToStateFile(raw) {
-  const statePath = (0, import_path2.join)(getConfigDir(), "state.json");
-  if ((0, import_fs2.existsSync)(statePath)) return;
+  const statePath = (0, import_path3.join)(getConfigDir(), "state.json");
+  if ((0, import_fs3.existsSync)(statePath)) return;
   const recentActivity = Array.isArray(raw.recentActivity) ? raw.recentActivity : [];
   const savedProviderSessions = Array.isArray(raw.savedProviderSessions) ? raw.savedProviderSessions : [];
   const legacySessionReads = isPlainObject(raw.recentSessionReads) ? raw.recentSessionReads : {};
@@ -1862,11 +2126,11 @@ function migrateStateToStateFile(raw) {
     sessionReads: mergedReads,
     sessionReadMarkers: cleanedMarkers
   };
-  (0, import_fs2.writeFileSync)(statePath, JSON.stringify(state, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs3.writeFileSync)(statePath, JSON.stringify(state, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function loadConfig() {
   const configPath = getConfigPath();
-  if (!(0, import_fs2.existsSync)(configPath)) {
+  if (!(0, import_fs3.existsSync)(configPath)) {
     const initialized = ensureMachineId({ ...DEFAULT_CONFIG });
     try {
       saveConfig(initialized.config);
@@ -1875,7 +2139,7 @@ function loadConfig() {
     return initialized.config;
   }
   try {
-    const raw = (0, import_fs2.readFileSync)(configPath, "utf-8");
+    const raw = (0, import_fs3.readFileSync)(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     migrateStateToStateFile(parsed);
     const normalizedInput = normalizeConfig(parsed);
@@ -1897,12 +2161,12 @@ function saveConfig(config) {
   const configPath = getConfigPath();
   const dir = getConfigDir();
   const normalized = normalizeConfig(config);
-  if (!(0, import_fs2.existsSync)(dir)) {
-    (0, import_fs2.mkdirSync)(dir, { recursive: true, mode: 448 });
+  if (!(0, import_fs3.existsSync)(dir)) {
+    (0, import_fs3.mkdirSync)(dir, { recursive: true, mode: 448 });
   }
-  (0, import_fs2.writeFileSync)(configPath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs3.writeFileSync)(configPath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
   try {
-    (0, import_fs2.chmodSync)(configPath, 384);
+    (0, import_fs3.chmodSync)(configPath, 384);
   } catch {
   }
 }
@@ -1929,13 +2193,13 @@ function isSetupComplete() {
 function resetConfig() {
   saveConfig({ ...DEFAULT_CONFIG });
 }
-var import_os, import_path2, import_fs2, import_crypto, DEFAULT_CONFIG, MACHINE_ID_PREFIX;
+var import_os, import_path3, import_fs3, import_crypto, DEFAULT_CONFIG, MACHINE_ID_PREFIX;
 var init_config = __esm({
   "src/config/config.ts"() {
     "use strict";
     import_os = require("os");
-    import_path2 = require("path");
-    import_fs2 = require("fs");
+    import_path3 = require("path");
+    import_fs3 = require("fs");
     import_crypto = require("crypto");
     DEFAULT_CONFIG = {
       serverUrl: "https://api.adhf.dev",
@@ -3367,13 +3631,13 @@ __export(mesh_config_exports, {
   updateNode: () => updateNode
 });
 function getMeshConfigPath() {
-  return (0, import_path3.join)(getConfigDir(), "meshes.json");
+  return (0, import_path4.join)(getConfigDir(), "meshes.json");
 }
 function loadMeshConfig() {
   const path46 = getMeshConfigPath();
-  if (!(0, import_fs3.existsSync)(path46)) return { meshes: [] };
+  if (!(0, import_fs4.existsSync)(path46)) return { meshes: [] };
   try {
-    const raw = JSON.parse((0, import_fs3.readFileSync)(path46, "utf-8"));
+    const raw = JSON.parse((0, import_fs4.readFileSync)(path46, "utf-8"));
     if (!raw || !Array.isArray(raw.meshes)) return { meshes: [] };
     const config = raw;
     const migrated = migrateLoadedMeshConfig(config);
@@ -3451,7 +3715,7 @@ function normalizeCapabilityTags(value) {
 }
 function saveMeshConfig(config) {
   const path46 = getMeshConfigPath();
-  (0, import_fs3.writeFileSync)(path46, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs4.writeFileSync)(path46, JSON.stringify(config, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function normalizeRepoIdentity(remoteUrl) {
   let identity = remoteUrl.trim();
@@ -3880,12 +4144,12 @@ function setDifficultyBrains(map) {
   saveMeshConfig(stored);
   return normalized;
 }
-var import_fs3, import_path3, import_crypto3, mergeMeshPolicy, MAGI_KIND_PANEL_KINDS, MAX_MAGI_KIND_SLOTS;
+var import_fs4, import_path4, import_crypto3, mergeMeshPolicy, MAGI_KIND_PANEL_KINDS, MAX_MAGI_KIND_SLOTS;
 var init_mesh_config = __esm({
   "src/config/mesh-config.ts"() {
     "use strict";
-    import_fs3 = require("fs");
-    import_path3 = require("path");
+    import_fs4 = require("fs");
+    import_path4 = require("path");
     import_crypto3 = require("crypto");
     init_hash();
     init_config();
@@ -5202,9 +5466,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 (0, import_path4.join)(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
+    return (0, import_path5.join)(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
   }
-  return (0, import_path4.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
+  return (0, import_path5.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
 }
 function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
   if (!meshId) return [];
@@ -5213,9 +5477,9 @@ function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
   const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   const events = [];
   for (const path46 of paths) {
-    if (!(0, import_fs4.existsSync)(path46)) continue;
+    if (!(0, import_fs5.existsSync)(path46)) continue;
     try {
-      const raw = (0, import_fs4.readFileSync)(path46, "utf-8");
+      const raw = (0, import_fs5.readFileSync)(path46, "utf-8");
       const parsed = raw.split("\n").filter(Boolean).flatMap((line) => {
         try {
           return [JSON.parse(line)];
@@ -5305,9 +5569,9 @@ function prunePendingMeshCoordinatorEventsRetention() {
 }
 function trimPendingEventsIfNeeded(path46) {
   try {
-    if (!(0, import_fs4.existsSync)(path46)) return;
-    if ((0, import_fs4.statSync)(path46).size <= MAX_PENDING_EVENTS_BYTES) return;
-    const lines = (0, import_fs4.readFileSync)(path46, "utf-8").split("\n").filter(Boolean);
+    if (!(0, import_fs5.existsSync)(path46)) return;
+    if ((0, import_fs5.statSync)(path46).size <= MAX_PENDING_EVENTS_BYTES) return;
+    const lines = (0, import_fs5.readFileSync)(path46, "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) {
@@ -5343,7 +5607,7 @@ function trimPendingEventsIfNeeded(path46) {
         LOG.warn("MeshEvents", `Failed to ledger-record trim-dropped ${event.event} for mesh ${event.meshId}: ${e?.message || e}`);
       }
     }
-    (0, import_fs4.writeFileSync)(path46, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
+    (0, import_fs5.writeFileSync)(path46, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
   } catch {
   }
 }
@@ -5455,7 +5719,7 @@ function persistPendingMeshCoordinatorEvent(event) {
     try {
       const path46 = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
       trimPendingEventsIfNeeded(path46);
-      (0, import_fs4.appendFileSync)(path46, JSON.stringify(event) + "\n", "utf-8");
+      (0, import_fs5.appendFileSync)(path46, JSON.stringify(event) + "\n", "utf-8");
     } catch (e) {
       if (!sqliteOk) throw e;
       LOG.warn("MeshEvents", `JSONL append failed for mesh ${event.meshId}; SQLite holds the event: ${e?.message || e}`);
@@ -5469,20 +5733,20 @@ function persistPendingMeshCoordinatorEvent(event) {
 function atomicDrainFile(path46) {
   const tmpPath = `${path46}.draining`;
   try {
-    (0, import_fs4.renameSync)(path46, tmpPath);
+    (0, import_fs5.renameSync)(path46, tmpPath);
   } catch {
     return null;
   }
   try {
-    const content = (0, import_fs4.readFileSync)(tmpPath, "utf-8");
+    const content = (0, import_fs5.readFileSync)(tmpPath, "utf-8");
     try {
-      (0, import_fs4.unlinkSync)(tmpPath);
+      (0, import_fs5.unlinkSync)(tmpPath);
     } catch {
     }
     return content;
   } catch {
     try {
-      (0, import_fs4.unlinkSync)(tmpPath);
+      (0, import_fs5.unlinkSync)(tmpPath);
     } catch {
     }
     return null;
@@ -5491,16 +5755,16 @@ function atomicDrainFile(path46) {
 function selectiveDrainFile(path46, predicate) {
   const tmpPath = `${path46}.draining`;
   try {
-    (0, import_fs4.renameSync)(path46, tmpPath);
+    (0, import_fs5.renameSync)(path46, tmpPath);
   } catch {
     return [];
   }
   let content;
   try {
-    content = (0, import_fs4.readFileSync)(tmpPath, "utf-8");
+    content = (0, import_fs5.readFileSync)(tmpPath, "utf-8");
   } catch {
     try {
-      (0, import_fs4.unlinkSync)(tmpPath);
+      (0, import_fs5.unlinkSync)(tmpPath);
     } catch {
     }
     return [];
@@ -5523,12 +5787,12 @@ function selectiveDrainFile(path46, predicate) {
   }
   try {
     if (keptLines.length > 0) {
-      (0, import_fs4.writeFileSync)(path46, keptLines.join("\n") + "\n", "utf-8");
+      (0, import_fs5.writeFileSync)(path46, keptLines.join("\n") + "\n", "utf-8");
     }
-    (0, import_fs4.unlinkSync)(tmpPath);
+    (0, import_fs5.unlinkSync)(tmpPath);
   } catch {
     try {
-      if ((0, import_fs4.existsSync)(tmpPath) && !(0, import_fs4.existsSync)(path46)) (0, import_fs4.renameSync)(tmpPath, path46);
+      if ((0, import_fs5.existsSync)(tmpPath) && !(0, import_fs5.existsSync)(path46)) (0, import_fs5.renameSync)(tmpPath, path46);
     } catch {
     }
     return [];
@@ -5756,18 +6020,18 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   }
   const paths = coordinatorDaemonId ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   for (const path46 of paths) {
-    if ((0, import_fs4.existsSync)(path46)) try {
-      (0, import_fs4.unlinkSync)(path46);
+    if ((0, import_fs5.existsSync)(path46)) try {
+      (0, import_fs5.unlinkSync)(path46);
     } catch {
     }
   }
 }
-var import_fs4, import_path4, import_crypto5, REFINE_TERMINAL_EVENTS, meshV2DrainCounters, warnedV2Violations, loggedSqlitePendingDrainFailure, TERMINAL_COMPLETION_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP, PENDING_EVENTS_DRAINED_RETENTION_MS, PENDING_EVENTS_UNDRAINED_RETENTION_MS;
+var import_fs5, import_path5, import_crypto5, REFINE_TERMINAL_EVENTS, meshV2DrainCounters, warnedV2Violations, loggedSqlitePendingDrainFailure, TERMINAL_COMPLETION_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP, PENDING_EVENTS_DRAINED_RETENTION_MS, PENDING_EVENTS_UNDRAINED_RETENTION_MS;
 var init_mesh_events_pending = __esm({
   "src/mesh/mesh-events-pending.ts"() {
     "use strict";
-    import_fs4 = require("fs");
-    import_path4 = require("path");
+    import_fs5 = require("fs");
+    import_path5 = require("path");
     import_crypto5 = require("crypto");
     init_logger();
     init_config();
@@ -7118,15 +7382,15 @@ function safeMeshId(meshId) {
   return meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function legacyQueuePath(meshId) {
-  return (0, import_path5.join)(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
+  return (0, import_path6.join)(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
 }
 function cleanupStrayRootRuntimeDb(canonicalPath) {
   try {
-    const strayPath = (0, import_path5.join)(getConfigDir(), "mesh-runtime.db");
+    const strayPath = (0, import_path6.join)(getConfigDir(), "mesh-runtime.db");
     if (strayPath === canonicalPath) return;
-    if (!(0, import_fs5.existsSync)(strayPath)) return;
-    if ((0, import_fs5.statSync)(strayPath).size !== 0) return;
-    (0, import_fs5.unlinkSync)(strayPath);
+    if (!(0, import_fs6.existsSync)(strayPath)) return;
+    if ((0, import_fs6.statSync)(strayPath).size !== 0) return;
+    (0, import_fs6.unlinkSync)(strayPath);
     if (!loggedStrayCleanup) {
       loggedStrayCleanup = true;
       LOG.info("MeshRuntimeStore", `Removed stray 0-byte root mesh-runtime.db at ${strayPath}`);
@@ -7140,17 +7404,17 @@ function cleanupStrayRootRuntimeDb(canonicalPath) {
 }
 function meshRuntimeStorePath() {
   const dir = getLedgerDir();
-  const nextPath = (0, import_path5.join)(dir, "mesh-runtime.db");
+  const nextPath = (0, import_path6.join)(dir, "mesh-runtime.db");
   cleanupStrayRootRuntimeDb(nextPath);
-  if ((0, import_fs5.existsSync)(nextPath)) return nextPath;
-  const legacyPath = (0, import_path5.join)(dir, "beads.db");
-  if (!(0, import_fs5.existsSync)(legacyPath)) return nextPath;
+  if ((0, import_fs6.existsSync)(nextPath)) return nextPath;
+  const legacyPath = (0, import_path6.join)(dir, "beads.db");
+  if (!(0, import_fs6.existsSync)(legacyPath)) return nextPath;
   try {
-    (0, import_fs5.renameSync)(legacyPath, nextPath);
+    (0, import_fs6.renameSync)(legacyPath, nextPath);
     for (const suffix of ["-wal", "-shm"]) {
       const legacyCompanion = `${legacyPath}${suffix}`;
-      if ((0, import_fs5.existsSync)(legacyCompanion)) {
-        (0, import_fs5.renameSync)(legacyCompanion, `${nextPath}${suffix}`);
+      if ((0, import_fs6.existsSync)(legacyCompanion)) {
+        (0, import_fs6.renameSync)(legacyCompanion, `${nextPath}${suffix}`);
       }
     }
   } catch (err) {
@@ -7161,7 +7425,7 @@ function meshRuntimeStorePath() {
         `Legacy beads.db\u2192mesh-runtime.db migration failed; using existing DB in-place to avoid data loss: ${err?.message || err}`
       );
     }
-    return (0, import_fs5.existsSync)(nextPath) ? nextPath : legacyPath;
+    return (0, import_fs6.existsSync)(nextPath) ? nextPath : legacyPath;
   }
   return nextPath;
 }
@@ -7180,12 +7444,12 @@ function pruneMeshRuntimeRetention() {
     return { ledger: 0, toolCalls: 0, terminalQueue: 0 };
   }
 }
-var import_fs5, import_path5, DatabaseCtor, loggedMigrationFailure, loggedStrayCleanup, MeshRuntimeStore, MESH_EVENT_LEDGER_RETENTION_MS, MESH_TOOL_CALL_LOG_RETENTION_MS, MESH_TERMINAL_QUEUE_RETENTION_MS;
+var import_fs6, import_path6, DatabaseCtor, loggedMigrationFailure, loggedStrayCleanup, MeshRuntimeStore, MESH_EVENT_LEDGER_RETENTION_MS, MESH_TOOL_CALL_LOG_RETENTION_MS, MESH_TERMINAL_QUEUE_RETENTION_MS;
 var init_mesh_runtime_store = __esm({
   "src/mesh/mesh-runtime-store.ts"() {
     "use strict";
-    import_fs5 = require("fs");
-    import_path5 = require("path");
+    import_fs6 = require("fs");
+    import_path6 = require("path");
     init_logger();
     init_load_better_sqlite3();
     init_config();
@@ -7216,8 +7480,8 @@ var init_mesh_runtime_store = __esm({
       static WAL_MAX_BYTES = 50 * 1024 * 1024;
       // 50 MB
       constructor(dbPath) {
-        const dir = (0, import_path5.dirname)(dbPath);
-        if (!(0, import_fs5.existsSync)(dir)) (0, import_fs5.mkdirSync)(dir, { recursive: true });
+        const dir = (0, import_path6.dirname)(dbPath);
+        if (!(0, import_fs6.existsSync)(dir)) (0, import_fs6.mkdirSync)(dir, { recursive: true });
         this.dbPath = dbPath;
         this.db = new (loadDatabaseCtor())(dbPath);
         this.db.pragma("journal_mode = WAL");
@@ -7596,8 +7860,8 @@ var init_mesh_runtime_store = __esm({
         this.walWriteCounter = 0;
         try {
           const walPath = `${this.dbPath}-wal`;
-          if (!(0, import_fs5.existsSync)(walPath)) return;
-          const size = (0, import_fs5.statSync)(walPath).size;
+          if (!(0, import_fs6.existsSync)(walPath)) return;
+          const size = (0, import_fs6.statSync)(walPath).size;
           if (size < _MeshRuntimeStore.WAL_MAX_BYTES) return;
           process.stderr.write(
             `[adhdev-mesh] WAL file ${Math.round(size / 1024 / 1024)}MB exceeds threshold; forcing checkpoint
@@ -7613,9 +7877,9 @@ var init_mesh_runtime_store = __esm({
         const count = this.db.prepare("SELECT COUNT(*) AS count FROM mesh_queue WHERE mesh_id = ?").get(meshId);
         if (count.count > 0) return;
         const path46 = legacyQueuePath(meshId);
-        if (!(0, import_fs5.existsSync)(path46)) return;
+        if (!(0, import_fs6.existsSync)(path46)) return;
         try {
-          const entries = JSON.parse((0, import_fs5.readFileSync)(path46, "utf-8"));
+          const entries = JSON.parse((0, import_fs6.readFileSync)(path46, "utf-8"));
           if (!Array.isArray(entries)) return;
           const insert = this.db.prepare(`
                 INSERT OR REPLACE INTO mesh_queue (
@@ -9066,41 +9330,41 @@ function isNoteExpired(note, now) {
   return now - created >= ttlDays * MS_PER_DAY;
 }
 function getLedgerDir() {
-  const dir = (0, import_path6.join)(getConfigDir(), LEDGER_DIR_NAME);
-  if (!(0, import_fs6.existsSync)(dir)) {
-    (0, import_fs6.mkdirSync)(dir, { recursive: true, mode: 448 });
+  const dir = (0, import_path7.join)(getConfigDir(), LEDGER_DIR_NAME);
+  if (!(0, import_fs7.existsSync)(dir)) {
+    (0, import_fs7.mkdirSync)(dir, { recursive: true, mode: 448 });
   }
   return dir;
 }
 function getLedgerPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path6.join)(getLedgerDir(), `${safe}.jsonl`);
+  return (0, import_path7.join)(getLedgerDir(), `${safe}.jsonl`);
 }
 function getRotatedPath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path6.join)(getLedgerDir(), `${safe}.${index}.jsonl`);
+  return (0, import_path7.join)(getLedgerDir(), `${safe}.${index}.jsonl`);
 }
 function getArchivePath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path6.join)(getLedgerDir(), `${safe}.archive.jsonl`);
+  return (0, import_path7.join)(getLedgerDir(), `${safe}.archive.jsonl`);
 }
 function getRotatedArchivePath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path6.join)(getLedgerDir(), `${safe}.archive.${index}.jsonl`);
+  return (0, import_path7.join)(getLedgerDir(), `${safe}.archive.${index}.jsonl`);
 }
 function getArchivedCountsPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path6.join)(getLedgerDir(), `${safe}.archived-counts.json`);
+  return (0, import_path7.join)(getLedgerDir(), `${safe}.archived-counts.json`);
 }
 function rotateArchiveFile(meshId, archivePath) {
   let index = 1;
-  while ((0, import_fs6.existsSync)(getRotatedArchivePath(meshId, index))) {
+  while ((0, import_fs7.existsSync)(getRotatedArchivePath(meshId, index))) {
     index++;
     if (index > 5) break;
   }
   if (index > 5) index = 5;
   try {
-    (0, import_fs6.renameSync)(archivePath, getRotatedArchivePath(meshId, index));
+    (0, import_fs7.renameSync)(archivePath, getRotatedArchivePath(meshId, index));
   } catch (e) {
     process.stderr.write(`[adhdev-mesh] Archive rotation failed for mesh ${meshId}: ${e?.message || e}
 `);
@@ -9108,9 +9372,9 @@ function rotateArchiveFile(meshId, archivePath) {
 }
 function readArchivedCounts(meshId) {
   const path46 = getArchivedCountsPath(meshId);
-  if (!(0, import_fs6.existsSync)(path46)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
+  if (!(0, import_fs7.existsSync)(path46)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
   try {
-    return JSON.parse((0, import_fs6.readFileSync)(path46, "utf-8"));
+    return JSON.parse((0, import_fs7.readFileSync)(path46, "utf-8"));
   } catch {
     return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
   }
@@ -9126,7 +9390,7 @@ function updateArchivedCounts(meshId, archived) {
   counts.totalArchived += archived.length;
   counts.lastArchivedAt = (/* @__PURE__ */ new Date()).toISOString();
   try {
-    (0, import_fs6.writeFileSync)(getArchivedCountsPath(meshId), JSON.stringify(counts), { encoding: "utf-8", mode: 384 });
+    (0, import_fs7.writeFileSync)(getArchivedCountsPath(meshId), JSON.stringify(counts), { encoding: "utf-8", mode: 384 });
   } catch {
   }
 }
@@ -9149,7 +9413,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
 }
 function compactLedger(meshId) {
   const filePath = getLedgerPath(meshId);
-  if (!(0, import_fs6.existsSync)(filePath)) return { archivedCount: 0, retainedCount: 0 };
+  if (!(0, import_fs7.existsSync)(filePath)) return { archivedCount: 0, retainedCount: 0 };
   const cutoff = Date.now() - ARCHIVE_TERMINAL_OLDER_THAN_MS;
   const entries = readLedgerEntries(meshId);
   const keep = [];
@@ -9164,11 +9428,11 @@ function compactLedger(meshId) {
   if (archive.length === 0) return { archivedCount: 0, retainedCount: keep.length };
   const archivePath = getArchivePath(meshId);
   try {
-    if ((0, import_fs6.existsSync)(archivePath) && (0, import_fs6.statSync)(archivePath).size > 50 * 1024 * 1024) {
+    if ((0, import_fs7.existsSync)(archivePath) && (0, import_fs7.statSync)(archivePath).size > 50 * 1024 * 1024) {
       rotateArchiveFile(meshId, archivePath);
     }
     const archiveLines = archive.map((e) => JSON.stringify(e)).join("\n") + "\n";
-    (0, import_fs6.appendFileSync)(archivePath, archiveLines, { encoding: "utf-8", mode: 384 });
+    (0, import_fs7.appendFileSync)(archivePath, archiveLines, { encoding: "utf-8", mode: 384 });
     updateArchivedCounts(meshId, archive);
   } catch (e) {
     process.stderr.write(`[adhdev-mesh] Ledger archive write failed for mesh ${meshId}: ${e?.message || e}
@@ -9177,7 +9441,7 @@ function compactLedger(meshId) {
   }
   try {
     const keepLines = keep.length ? keep.map((e) => JSON.stringify(e)).join("\n") + "\n" : "";
-    (0, import_fs6.writeFileSync)(filePath, keepLines, { encoding: "utf-8", mode: 384 });
+    (0, import_fs7.writeFileSync)(filePath, keepLines, { encoding: "utf-8", mode: 384 });
     invalidateLedgerCache(meshId);
   } catch (e) {
     process.stderr.write(`[adhdev-mesh] Ledger compaction rewrite failed for mesh ${meshId}: ${e?.message || e}
@@ -9355,9 +9619,9 @@ function appendLedgerEntry(meshId, partial) {
     ...partial
   };
   const filePath = getLedgerPath(meshId);
-  if ((0, import_fs6.existsSync)(filePath)) {
+  if ((0, import_fs7.existsSync)(filePath)) {
     try {
-      const stat2 = (0, import_fs6.statSync)(filePath);
+      const stat2 = (0, import_fs7.statSync)(filePath);
       if (stat2.size >= MAX_FILE_SIZE_BYTES) {
         rotateLedgerFile(meshId, filePath);
       } else if (stat2.size >= COMPACT_THRESHOLD_BYTES) {
@@ -9382,7 +9646,7 @@ function appendLedgerEntry(meshId, partial) {
   }
   try {
     const line = JSON.stringify(entry) + "\n";
-    (0, import_fs6.appendFileSync)(filePath, line, { encoding: "utf-8", mode: 384 });
+    (0, import_fs7.appendFileSync)(filePath, line, { encoding: "utf-8", mode: 384 });
     invalidateLedgerCache(meshId);
     meshLedgerEvents.emit("append", meshId, entry);
     if (entry.kind === OPERATING_NOTE_KIND || entry.kind === OPERATING_NOTE_TOMBSTONE_KIND) {
@@ -9474,7 +9738,7 @@ function pruneOperatingNotes(meshId, keepLatest = OPERATING_NOTE_KEEP_LATEST) {
     const remaining = readLedgerFile(meshId).filter((e) => !removeIds.includes(e.id));
     const filePath = getLedgerPath(meshId);
     const lines = remaining.length ? remaining.map((e) => JSON.stringify(e)).join("\n") + "\n" : "";
-    (0, import_fs6.writeFileSync)(filePath, lines, { encoding: "utf-8", mode: 384 });
+    (0, import_fs7.writeFileSync)(filePath, lines, { encoding: "utf-8", mode: 384 });
   } catch {
   }
   invalidateLedgerCache(meshId);
@@ -9531,7 +9795,7 @@ function appendRemoteLedgerEntries(meshId, entries) {
   }
   try {
     const lines = validEntries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-    (0, import_fs6.appendFileSync)(ledgerPath, lines, { encoding: "utf-8", mode: 384 });
+    (0, import_fs7.appendFileSync)(ledgerPath, lines, { encoding: "utf-8", mode: 384 });
     invalidateLedgerCache(meshId);
     for (const entry of validEntries) {
       meshLedgerEvents.emit("append", meshId, entry);
@@ -9543,10 +9807,10 @@ function appendRemoteLedgerEntries(meshId, entries) {
 }
 function readLedgerFile(meshId) {
   const filePath = getLedgerPath(meshId);
-  if (!(0, import_fs6.existsSync)(filePath)) return [];
+  if (!(0, import_fs7.existsSync)(filePath)) return [];
   let content;
   try {
-    content = (0, import_fs6.readFileSync)(filePath, "utf-8");
+    content = (0, import_fs7.readFileSync)(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -9811,24 +10075,24 @@ function getSessionRecoveryContext(meshId, opts) {
 }
 function rotateLedgerFile(meshId, currentPath) {
   let index = 1;
-  while ((0, import_fs6.existsSync)(getRotatedPath(meshId, index))) {
+  while ((0, import_fs7.existsSync)(getRotatedPath(meshId, index))) {
     index++;
     if (index > 10) break;
   }
   if (index > 10) index = 10;
   try {
-    (0, import_fs6.renameSync)(currentPath, getRotatedPath(meshId, index));
+    (0, import_fs7.renameSync)(currentPath, getRotatedPath(meshId, index));
   } catch (e) {
     process.stderr.write(`[adhdev-mesh] Ledger rotation failed for mesh ${meshId}: ${e?.message || e}. File will continue to grow.
 `);
   }
 }
-var import_fs6, import_path6, import_crypto8, import_events, LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, COMPACT_THRESHOLD_BYTES, ARCHIVE_TERMINAL_OLDER_THAN_MS, RECENT_FAILURE_WINDOW_MS, ARCHIVABLE_KINDS, DEFAULT_LEDGER_SLICE_LIMIT, MAX_LEDGER_SLICE_LIMIT, OPERATING_NOTE_KIND, OPERATING_NOTE_TOMBSTONE_KIND, OPERATING_NOTE_DEDUPE_WINDOW, OPERATING_NOTE_KEEP_LATEST, OPERATING_NOTE_CATEGORY_TTL_DAYS, MS_PER_DAY, meshLedgerEvents, ledgerReadCache, LEDGER_CACHE_TTL_MS, ledgerImportStoreRef, ledgerImportDone;
+var import_fs7, import_path7, import_crypto8, import_events, LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, COMPACT_THRESHOLD_BYTES, ARCHIVE_TERMINAL_OLDER_THAN_MS, RECENT_FAILURE_WINDOW_MS, ARCHIVABLE_KINDS, DEFAULT_LEDGER_SLICE_LIMIT, MAX_LEDGER_SLICE_LIMIT, OPERATING_NOTE_KIND, OPERATING_NOTE_TOMBSTONE_KIND, OPERATING_NOTE_DEDUPE_WINDOW, OPERATING_NOTE_KEEP_LATEST, OPERATING_NOTE_CATEGORY_TTL_DAYS, MS_PER_DAY, meshLedgerEvents, ledgerReadCache, LEDGER_CACHE_TTL_MS, ledgerImportStoreRef, ledgerImportDone;
 var init_mesh_ledger = __esm({
   "src/mesh/mesh-ledger.ts"() {
     "use strict";
-    import_fs6 = require("fs");
-    import_path6 = require("path");
+    import_fs7 = require("fs");
+    import_path7 = require("path");
     import_crypto8 = require("crypto");
     init_config();
     init_dist();
@@ -11213,13 +11477,13 @@ var init_mesh_coordinator = __esm({
 
 // src/mesh/coordinator-registry.ts
 function getRegistryPath() {
-  return (0, import_path7.join)(getDaemonDataDir(), "mesh-coordinators.json");
+  return (0, import_path8.join)(getDaemonDataDir(), "mesh-coordinators.json");
 }
 function loadMeshCoordinatorRegistry() {
   const path46 = getRegistryPath();
-  if (!(0, import_fs7.existsSync)(path46)) return;
+  if (!(0, import_fs8.existsSync)(path46)) return;
   try {
-    const raw = JSON.parse((0, import_fs7.readFileSync)(path46, "utf-8"));
+    const raw = JSON.parse((0, import_fs8.readFileSync)(path46, "utf-8"));
     if (!Array.isArray(raw)) return;
     _registry.clear();
     for (const entry of raw) {
@@ -11232,7 +11496,7 @@ function loadMeshCoordinatorRegistry() {
 }
 function saveRegistry() {
   try {
-    (0, import_fs7.writeFileSync)(
+    (0, import_fs8.writeFileSync)(
       getRegistryPath(),
       JSON.stringify([..._registry.values()], null, 2),
       { encoding: "utf-8", mode: 384 }
@@ -11265,12 +11529,12 @@ function getCoordinatorForSession(sessionId) {
 function listCoordinatorsForWorkspace(workspace) {
   return [..._registry.values()].filter((e) => e.workspace === workspace);
 }
-var import_path7, import_fs7, _registry;
+var import_path8, import_fs8, _registry;
 var init_coordinator_registry = __esm({
   "src/mesh/coordinator-registry.ts"() {
     "use strict";
-    import_path7 = require("path");
-    import_fs7 = require("fs");
+    import_path8 = require("path");
+    import_fs8 = require("fs");
     init_config();
     _registry = /* @__PURE__ */ new Map();
   }
@@ -11360,14 +11624,14 @@ function validateMeshRefineConfig(config, source = "inline") {
   const rejectedCommands = [];
   const deprecationWarnings = [];
   let bootstrapMode = "inherit";
-  if (!isRecord2(config)) return { valid: false, errors: ["config must be an object"], bootstrapCommands, commands, rejectedCommands, bootstrapMode, deprecationWarnings };
+  if (!isRecord3(config)) return { valid: false, errors: ["config must be an object"], bootstrapCommands, commands, rejectedCommands, bootstrapMode, deprecationWarnings };
   if (config.version !== 1) errors.push("version must be 1");
   if (config.allowAutoPublishSubmoduleMainCommits !== void 0 && typeof config.allowAutoPublishSubmoduleMainCommits !== "boolean") {
     errors.push("allowAutoPublishSubmoduleMainCommits must be a boolean when provided");
   }
   const validation = config.validation;
-  if (validation !== void 0 && !isRecord2(validation)) errors.push("validation must be an object");
-  const rawBootstrapMode = isRecord2(validation) ? validation.bootstrap : void 0;
+  if (validation !== void 0 && !isRecord3(validation)) errors.push("validation must be an object");
+  const rawBootstrapMode = isRecord3(validation) ? validation.bootstrap : void 0;
   if (rawBootstrapMode !== void 0) {
     if (rawBootstrapMode === "inherit" || rawBootstrapMode === "skip") {
       bootstrapMode = rawBootstrapMode;
@@ -11375,8 +11639,8 @@ function validateMeshRefineConfig(config, source = "inline") {
       errors.push("validation.bootstrap must be 'inherit' or 'skip' when provided");
     }
   }
-  const rawCommands = isRecord2(validation) ? validation.commands : void 0;
-  const rawBootstrapCommands = isRecord2(validation) ? validation.bootstrapCommands : void 0;
+  const rawCommands = isRecord3(validation) ? validation.commands : void 0;
+  const rawBootstrapCommands = isRecord3(validation) ? validation.bootstrapCommands : void 0;
   if (rawCommands !== void 0 && !Array.isArray(rawCommands)) errors.push("validation.commands must be an array");
   if (rawBootstrapCommands !== void 0 && !Array.isArray(rawBootstrapCommands)) errors.push("validation.bootstrapCommands must be an array");
   if (Array.isArray(rawBootstrapCommands) && rawBootstrapCommands.length > 0) {
@@ -11399,9 +11663,9 @@ function validateMeshRefineConfig(config, source = "inline") {
   if (rejectedCommands.length) errors.push("one or more validation commands are invalid");
   return { valid: errors.length === 0, errors, bootstrapCommands, commands, rejectedCommands, bootstrapMode, deprecationWarnings };
 }
-function parseConfigText2(path46, text) {
+function parseConfigText3(path46, text) {
   if (/\.json$/i.test(path46)) return JSON.parse(text);
-  return yaml2.load(text);
+  return yaml3.load(text);
 }
 function loadMeshRefineConfig(mesh, workspace) {
   const policy = mesh?.policy && typeof mesh.policy === "object" && !Array.isArray(mesh.policy) ? mesh.policy : {};
@@ -11412,10 +11676,10 @@ function loadMeshRefineConfig(mesh, workspace) {
     return { config: inline, source: "mesh.policy.refineConfig", sourceType: "mesh_policy" };
   }
   for (const relative5 of MESH_REFINE_CONFIG_LOCATIONS) {
-    const configPath = (0, import_path8.join)(workspace, relative5);
-    if (!(0, import_fs8.existsSync)(configPath)) continue;
+    const configPath = (0, import_path9.join)(workspace, relative5);
+    if (!(0, import_fs9.existsSync)(configPath)) continue;
     try {
-      const parsed = parseConfigText2(configPath, (0, import_fs8.readFileSync)(configPath, "utf-8"));
+      const parsed = parseConfigText3(configPath, (0, import_fs9.readFileSync)(configPath, "utf-8"));
       const validation = validateMeshRefineConfig(parsed, relative5);
       if (!validation.valid) return { source: relative5, sourceType: "invalid", path: configPath, error: String(validation.rejectedCommands[0]?.reason || validation.errors.join("; ")) };
       return { config: parsed, source: relative5, sourceType: "repo_file", path: configPath };
@@ -11431,20 +11695,20 @@ function loadMeshRefineConfig(mesh, workspace) {
 }
 function readPackageScripts(workspace) {
   try {
-    const parsed = JSON.parse((0, import_fs8.readFileSync)((0, import_path8.join)(workspace, "package.json"), "utf-8"));
-    return isRecord2(parsed?.scripts) ? parsed.scripts : {};
+    const parsed = JSON.parse((0, import_fs9.readFileSync)((0, import_path9.join)(workspace, "package.json"), "utf-8"));
+    return isRecord3(parsed?.scripts) ? parsed.scripts : {};
   } catch {
     return {};
   }
 }
 function collectProjectContextSuggestions(mesh) {
   const commands = mesh?.projectContext?.commands;
-  if (!isRecord2(commands)) return [];
+  if (!isRecord3(commands)) return [];
   const suggestions = [];
   for (const category of MESH_REFINE_VALIDATION_CATEGORIES) {
     const entries = Array.isArray(commands[category]) ? commands[category] : [];
     for (const entry of entries) {
-      if (isRecord2(entry) && typeof entry.command === "string") suggestions.push({ command: entry.command, category });
+      if (isRecord3(entry) && typeof entry.command === "string") suggestions.push({ command: entry.command, category });
     }
   }
   return suggestions;
@@ -11506,13 +11770,13 @@ function resolveMeshRefineValidationPlan(mesh, workspace) {
     unavailableReason: validation.commands.length ? void 0 : "validation_unavailable: repo mesh/refine config has no validation.commands"
   };
 }
-var import_fs8, import_path8, yaml2, MESH_REFINE_VALIDATION_CATEGORIES, MESH_REFINE_VALIDATION_SCOPES, MESH_REFINE_CONFIG_LOCATIONS, MESH_REFINE_CONFIG_SCHEMA, SHELL_METACHAR_RE, SAFE_TOKEN_RE, SAFE_WIN32_EXEC_TOKEN_RE, isRecord2;
+var import_fs9, import_path9, yaml3, MESH_REFINE_VALIDATION_CATEGORIES, MESH_REFINE_VALIDATION_SCOPES, MESH_REFINE_CONFIG_LOCATIONS, MESH_REFINE_CONFIG_SCHEMA, SHELL_METACHAR_RE, SAFE_TOKEN_RE, SAFE_WIN32_EXEC_TOKEN_RE, isRecord3;
 var init_refine_config = __esm({
   "src/mesh/refine-config.ts"() {
     "use strict";
-    import_fs8 = require("fs");
-    import_path8 = require("path");
-    yaml2 = __toESM(require("js-yaml"));
+    import_fs9 = require("fs");
+    import_path9 = require("path");
+    yaml3 = __toESM(require("js-yaml"));
     MESH_REFINE_VALIDATION_CATEGORIES = ["typecheck", "test", "lint", "build"];
     MESH_REFINE_VALIDATION_SCOPES = ["none", "web", "daemon"];
     MESH_REFINE_CONFIG_LOCATIONS = [
@@ -11603,7 +11867,7 @@ var init_refine_config = __esm({
     SHELL_METACHAR_RE = /[;&|<>`$\n\r'"]/;
     SAFE_TOKEN_RE = /^[A-Za-z0-9_@./:=+-]+$/;
     SAFE_WIN32_EXEC_TOKEN_RE = /^[A-Za-z0-9_@./:=+\\-]+$/;
-    isRecord2 = isMeshConfigRecord;
+    isRecord3 = isMeshConfigRecord;
   }
 });
 
@@ -11622,7 +11886,7 @@ function resolveWin32GlobalBin(trimmed) {
     if (!dir) continue;
     for (const ext of WIN_EXEC_EXT) {
       const full = path10.join(dir, trimmed + ext);
-      if ((0, import_fs9.existsSync)(full)) return full;
+      if ((0, import_fs10.existsSync)(full)) return full;
     }
   }
   return null;
@@ -11639,7 +11903,7 @@ function resolveWin32Executable(command) {
   if (process.platform !== "win32") return command;
   const trimmed = (command || "").trim();
   if (!trimmed) return command;
-  if (path10.isAbsolute(trimmed) && (0, import_fs9.existsSync)(trimmed)) return trimmed;
+  if (path10.isAbsolute(trimmed) && (0, import_fs10.existsSync)(trimmed)) return trimmed;
   try {
     const out = (0, import_child_process.execFileSync)("where", [trimmed], {
       encoding: "utf8",
@@ -11687,12 +11951,12 @@ function buildWin32ExecFileSpawn(resolvedCommand, args) {
     windowsVerbatimArguments: true
   };
 }
-var import_child_process, import_fs9, path10, DIRECT_EXEC_EXT, SHIM_EXEC_EXT, WIN_EXEC_EXT;
+var import_child_process, import_fs10, path10, DIRECT_EXEC_EXT, SHIM_EXEC_EXT, WIN_EXEC_EXT;
 var init_resolve_executable = __esm({
   "src/cli-adapters/resolve-executable.ts"() {
     "use strict";
     import_child_process = require("child_process");
-    import_fs9 = require("fs");
+    import_fs10 = require("fs");
     path10 = __toESM(require("path"));
     DIRECT_EXEC_EXT = /* @__PURE__ */ new Set([".exe", ".com"]);
     SHIM_EXEC_EXT = /* @__PURE__ */ new Set([".cmd", ".bat"]);
@@ -11832,7 +12096,7 @@ function isWorktreeBootstrapStaleRunning(node, nowMs = Date.now()) {
   if (!Number.isFinite(startedMs)) return false;
   if (nowMs - startedMs <= WORKTREE_BOOTSTRAP_STALE_RUNNING_MS) return false;
   const workspace = typeof node?.workspace === "string" ? node.workspace.trim() : "";
-  if (!workspace || !(0, import_fs10.existsSync)(workspace)) return false;
+  if (!workspace || !(0, import_fs11.existsSync)(workspace)) return false;
   try {
     const out = (0, import_node_child_process3.execFileSync)(resolveWin32Executable("git"), ["status", "--porcelain"], {
       cwd: workspace,
@@ -11853,9 +12117,9 @@ function shouldDeferDispatchForBootstrap(node, nowMs = Date.now()) {
   if (node?.worktreeBootstrap?.status !== "running") return false;
   return !isWorktreeBootstrapStaleRunning(node, nowMs);
 }
-function parseConfigText3(path46, text) {
+function parseConfigText4(path46, text) {
   if (/\.json$/i.test(path46)) return JSON.parse(text);
-  return yaml3.load(text);
+  return yaml4.load(text);
 }
 function truncateOutput(value) {
   const text = typeof value === "string" ? value : value == null ? "" : String(value);
@@ -11895,10 +12159,10 @@ function loadMeshWorktreeBootstrapConfig(mesh, workspace) {
     return { config: inline, source: "mesh.policy.worktreeBootstrapConfig", sourceType: "mesh_policy" };
   }
   for (const relative5 of MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS) {
-    const configPath = (0, import_path9.join)(workspace, relative5);
-    if (!(0, import_fs10.existsSync)(configPath)) continue;
+    const configPath = (0, import_path10.join)(workspace, relative5);
+    if (!(0, import_fs11.existsSync)(configPath)) continue;
     try {
-      const parsed = parseConfigText3(configPath, (0, import_fs10.readFileSync)(configPath, "utf-8"));
+      const parsed = parseConfigText4(configPath, (0, import_fs11.readFileSync)(configPath, "utf-8"));
       const validation = validateMeshWorktreeBootstrapConfig(parsed, relative5);
       if (!validation.valid) return { source: relative5, sourceType: "invalid", path: configPath, error: String(validation.rejectedCommands[0]?.reason || validation.errors.join("; ")) };
       return { config: parsed, source: relative5, sourceType: "repo_file", path: configPath };
@@ -11911,9 +12175,9 @@ function loadMeshWorktreeBootstrapConfig(mesh, workspace) {
 function computeStaleInputsDigest(workspace, staleInputs) {
   const digest = {};
   for (const relative5 of staleInputs ?? []) {
-    const filePath = (0, import_path9.join)(workspace, relative5);
+    const filePath = (0, import_path10.join)(workspace, relative5);
     try {
-      digest[relative5] = (0, import_node_crypto2.createHash)("sha256").update((0, import_fs10.readFileSync)(filePath)).digest("hex");
+      digest[relative5] = (0, import_node_crypto2.createHash)("sha256").update((0, import_fs11.readFileSync)(filePath)).digest("hex");
     } catch {
       digest[relative5] = "absent";
     }
@@ -11984,10 +12248,10 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
     staleInputs: loaded.config.staleInputs
   };
   const staleInputPaths = loaded.config.staleInputs ?? [];
-  const initiallyAbsent = staleInputPaths.filter((p) => !(0, import_fs10.existsSync)((0, import_path9.join)(workspace, p)));
+  const initiallyAbsent = staleInputPaths.filter((p) => !(0, import_fs11.existsSync)((0, import_path10.join)(workspace, p)));
   for (const command of validation.commands) {
     if (initiallyAbsent.length > 0) {
-      const appearedNow = initiallyAbsent.filter((p) => (0, import_fs10.existsSync)((0, import_path9.join)(workspace, p)));
+      const appearedNow = initiallyAbsent.filter((p) => (0, import_fs11.existsSync)((0, import_path10.join)(workspace, p)));
       if (appearedNow.length > 0) {
         state.status = "stale";
         state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -11995,7 +12259,7 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
         return state;
       }
     }
-    const cwd = command.cwd ? (0, import_path9.resolve)(workspace, command.cwd) : workspace;
+    const cwd = command.cwd ? (0, import_path10.resolve)(workspace, command.cwd) : workspace;
     const startedAt = Date.now();
     state.lastCommand = command.displayCommand;
     const resolvedCommand = resolveWin32Executable(command.command);
@@ -12055,16 +12319,16 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
   }
   return state;
 }
-var import_fs10, import_path9, import_node_child_process3, import_node_crypto2, import_node_util3, yaml3, WORKTREE_BOOTSTRAP_STALE_RUNNING_MS, SUBMODULE_DEFAULT_BRANCH_FALLBACK, MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS, MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA, DEFAULT_TIMEOUT_MS2, DEFAULT_OUTPUT_LIMIT_BYTES, OUTPUT_SUMMARY_CHARS;
+var import_fs11, import_path10, import_node_child_process3, import_node_crypto2, import_node_util3, yaml4, WORKTREE_BOOTSTRAP_STALE_RUNNING_MS, SUBMODULE_DEFAULT_BRANCH_FALLBACK, MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS, MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA, DEFAULT_TIMEOUT_MS2, DEFAULT_OUTPUT_LIMIT_BYTES, OUTPUT_SUMMARY_CHARS;
 var init_worktree_bootstrap_config = __esm({
   "src/mesh/worktree-bootstrap-config.ts"() {
     "use strict";
-    import_fs10 = require("fs");
-    import_path9 = require("path");
+    import_fs11 = require("fs");
+    import_path10 = require("path");
     import_node_child_process3 = require("child_process");
     import_node_crypto2 = require("crypto");
     import_node_util3 = require("util");
-    yaml3 = __toESM(require("js-yaml"));
+    yaml4 = __toESM(require("js-yaml"));
     init_resolve_executable();
     init_refine_config();
     WORKTREE_BOOTSTRAP_STALE_RUNNING_MS = 10 * 60 * 1e3;
@@ -12116,224 +12380,6 @@ 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
-});
-function isRecord3(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function parseConfigText4(path46, text) {
-  if (/\.json$/i.test(path46)) 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 } : {},
-    // Operating-notes lifecycle: a repo-declared note may pin itself or set an
-    // explicit expiry, same as a runtime-recorded one. Phase 2 (b)/(c): it may
-    // also declare supersedes/subjectKey to retire an earlier note or group
-    // same-subject notes for folding.
-    ...value.pinned === true ? { pinned: true } : {},
-    ...typeof value.expiresAt === "string" ? { expiresAt: value.expiresAt } : {},
-    ...typeof value.supersedes === "string" ? { supersedes: value.supersedes } : {},
-    ...typeof value.subjectKey === "string" ? { subjectKey: value.subjectKey } : {}
-  };
-}
-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 = (0, import_path10.join)(base, relative5);
-      if (!(0, import_fs11.existsSync)(configPath)) continue;
-      try {
-        const parsed = parseConfigText4(configPath, (0, import_fs11.readFileSync)(configPath, "utf-8"));
-        const result = normalizeRepoMeshDeclarativeConfig(parsed);
-        if (!result.valid || !result.config) {
-          return { source: relative5, sourceType: "invalid", path: configPath, error: result.errors.join("; ") };
-        }
-        return { config: result.config, source: relative5, sourceType: "repo_file", path: configPath };
-      } catch (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 import_fs11, import_path10, yaml4, MESH_JSON_CONFIG_LOCATIONS, MESH_JSON_CONFIG_SCHEMA;
-var init_mesh_json_config = __esm({
-  "src/config/mesh-json-config.ts"() {
-    "use strict";
-    import_fs11 = require("fs");
-    import_path10 = require("path");
-    yaml4 = __toESM(require("js-yaml"));
-    MESH_JSON_CONFIG_LOCATIONS = [
-      ".adhdev/mesh.json",
-      ".adhdev/mesh.yaml",
-      ".adhdev/mesh.yml"
-    ];
-    MESH_JSON_CONFIG_SCHEMA = {
-      $schema: "https://json-schema.org/draft/2020-12/schema",
-      title: "ADHDev Repo Mesh Declarative Config",
-      type: "object",
-      additionalProperties: false,
-      required: ["version"],
-      properties: {
-        version: { const: 1 },
-        coordinator: {
-          type: "object",
-          additionalProperties: false,
-          properties: {
-            systemPromptOverride: { type: "string" },
-            systemPromptAppend: { type: "string" },
-            maxPromptChars: { type: "number", minimum: 1 }
-          }
-        },
-        operatingNotes: {
-          type: "array",
-          maxItems: 200,
-          items: {
-            type: "object",
-            additionalProperties: false,
-            required: ["text"],
-            properties: {
-              text: { type: "string", minLength: 1 },
-              category: { enum: ["provider_quirk", "pattern_to_avoid", "recovery_lesson"] },
-              createdAt: { type: "string" },
-              sourceCoordinator: { type: "string" }
-            }
-          }
-        },
-        limits: {
-          type: "object",
-          additionalProperties: false,
-          properties: {
-            maxNoteChars: { type: "number", minimum: 1 },
-            maxNotes: { type: "number", minimum: 1 }
-          }
-        }
-      }
-    };
-  }
-});
-
 // src/mesh/mesh-fast-forward.ts
 async function fastForwardMeshNode(args) {
   const workspace = typeof args.workspace === "string" ? args.workspace.trim() : "";
@@ -16657,6 +16703,16 @@ function __resetIdleAutoFastForwardForTests() {
   continuousAutoFastForwardLastScan.clear();
   autoFastForwardWorkspaceLease.clear();
 }
+function loadRepoConfigForNode(node) {
+  const workspace = typeof node?.workspace === "string" && node.workspace.trim() ? node.workspace.trim() : "";
+  if (!workspace) return null;
+  try {
+    const result = loadRepoMeshJsonConfig(workspace);
+    return result.sourceType === "repo_file" && result.config ? result.config : null;
+  } catch {
+    return null;
+  }
+}
 function getMeshWithCache(components, meshId) {
   const localMesh = getMesh(meshId);
   const cachedMesh = components.router?.getCachedInlineMesh(meshId);
@@ -16919,7 +16975,9 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
         ...delegatedWorkerAutoApproveSettings(
           mesh?.policy,
           node?.policy,
-          components.providerLoader?.getMeta(providerType)
+          components.providerLoader?.getMeta(providerType),
+          loadRepoConfigForNode(node),
+          providerType
         ),
         ...localDaemonId ? { meshCoordinatorDaemonId: localDaemonId } : {},
         // COMPLETION-PROPAGATION F5: (re)stamp the coordinator SESSION anchor from THIS
@@ -17358,10 +17416,10 @@ function liveSessionCountForNode(components, meshId, nodeId) {
   }
   return count;
 }
-function nodeHasLiveSessionPendingClaim(components, meshId, nodeId) {
+function nodeHasLiveSessionPendingClaim(components, meshId, nodeId, task, node) {
   if (inWindowAutoLaunchSessionIdsForNode(meshId, nodeId).length > 0) return true;
   const busySessionIds = new Set(
-    getQueue(meshId, { status: ["assigned"] }).filter((task) => daemonIdsEquivalent(task.assignedNodeId, nodeId)).map((task) => readNonEmptyString(task.assignedSessionId)).filter(Boolean)
+    getQueue(meshId, { status: ["assigned"] }).filter((task2) => daemonIdsEquivalent(task2.assignedNodeId, nodeId)).map((task2) => readNonEmptyString(task2.assignedSessionId)).filter(Boolean)
   );
   return components.instanceManager.getByCategory("cli").some((inst) => {
     const state = inst.getState();
@@ -17374,6 +17432,12 @@ function nodeHasLiveSessionPendingClaim(components, meshId, nodeId) {
     if (isTerminalSessionStatus(status)) return false;
     const sessionId = readNonEmptyString(state.instanceId);
     if (sessionId && busySessionIds.has(sessionId)) return false;
+    if (task.requiredTags?.length) {
+      const sessionProviderType = state.type || readNonEmptyString(settings.providerType);
+      if (sessionProviderType && !nodeSatisfiesRequiredTags(task.requiredTags, buildMeshNodeCapabilityTags(node, sessionProviderType))) {
+        return false;
+      }
+    }
     return true;
   });
 }
@@ -17654,7 +17718,7 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
         sweepExpiredCooldowns();
         continue;
       }
-      if (nodeHasLiveSessionPendingClaim(components, meshId, nodeId)) {
+      if (nodeHasLiveSessionPendingClaim(components, meshId, nodeId, task, node)) {
         markAutoLaunch(meshId, task.id, { status: "skipped", reason: "node_has_live_session_pending_claim", nodeId });
         continue;
       }
@@ -17697,7 +17761,9 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
           ...delegatedWorkerAutoApproveSettings(
             mesh?.policy,
             node?.policy,
-            components.providerLoader?.getMeta(resolved.providerType)
+            components.providerLoader?.getMeta(resolved.providerType),
+            loadRepoConfigForNode(node),
+            resolved.providerType
           ),
           launchedByCoordinator: true,
           autoLaunchedForQueueTaskId: task.id
@@ -18163,6 +18229,7 @@ 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_node_slots();
     init_mesh_events_stale();
@@ -21721,7 +21788,20 @@ function injectMeshSystemMessage(components, args) {
                   ...delegatedWorkerAutoApproveSettings(
                     mesh?.policy,
                     node?.policy,
-                    components.providerLoader?.getMeta(recoveryContext.failedProviderType)
+                    components.providerLoader?.getMeta(recoveryContext.failedProviderType),
+                    // Recovery relaunch: same repo-declared requested mode as the
+                    // primary path. node.workspace missing → null → provider default.
+                    (() => {
+                      const ws = typeof node?.workspace === "string" && node.workspace.trim() ? node.workspace.trim() : "";
+                      if (!ws) return null;
+                      try {
+                        const r = loadRepoMeshJsonConfig(ws);
+                        return r.sourceType === "repo_file" && r.config ? r.config : null;
+                      } catch {
+                        return null;
+                      }
+                    })(),
+                    recoveryContext.failedProviderType
                   ),
                   launchedByCoordinator: true
                 }
@@ -22112,6 +22192,7 @@ var init_mesh_event_forwarding = __esm({
     init_mesh_event_trace();
     init_snapshot();
     init_repo_mesh_types();
+    init_mesh_json_config();
     init_dist();
     init_mesh_events_stale();
     init_mesh_task_inflight();
@@ -30556,6 +30637,9 @@ __export(index_exports, {
   MAX_LEDGER_SLICE_LIMIT: () => MAX_LEDGER_SLICE_LIMIT,
   MESH_CONVERGE_FAST_FORWARD_TAG: () => MESH_CONVERGE_FAST_FORWARD_TAG,
   MESH_CONVERGE_REFINE_TAG: () => MESH_CONVERGE_REFINE_TAG,
+  MESH_JSON_CONFIG_LOCATIONS: () => MESH_JSON_CONFIG_LOCATIONS,
+  MESH_JSON_CONFIG_SCHEMA: () => MESH_JSON_CONFIG_SCHEMA,
+  MESH_JSON_PROVIDER_DEFAULTS_EXAMPLE: () => MESH_JSON_PROVIDER_DEFAULTS_EXAMPLE,
   MESH_MAX_PARALLEL_TASKS_MAX: () => MESH_MAX_PARALLEL_TASKS_MAX,
   MESH_MAX_PARALLEL_TASKS_MIN: () => MESH_MAX_PARALLEL_TASKS_MIN,
   MESH_MISSION_LIST_HISTORY_ID_LIMIT: () => MESH_MISSION_LIST_HISTORY_ID_LIMIT,
@@ -30615,6 +30699,7 @@ __export(index_exports, {
   buildMeshActiveWorkSummary: () => buildMeshActiveWorkSummary,
   buildMeshAsyncRefineJobs: () => buildMeshAsyncRefineJobs,
   buildMeshHostRequiredFailure: () => buildMeshHostRequiredFailure,
+  buildMeshJsonConfigScaffold: () => buildMeshJsonConfigScaffold,
   buildMeshLedgerReconciliationEvidence: () => buildMeshLedgerReconciliationEvidence,
   buildMeshLedgerReplicaEvidence: () => buildMeshLedgerReplicaEvidence,
   buildMeshMagiActivity: () => buildMeshMagiActivity,
@@ -30779,6 +30864,7 @@ __export(index_exports, {
   loadMeshCoordinatorRegistry: () => loadMeshCoordinatorRegistry,
   loadMeshRefineConfig: () => loadMeshRefineConfig,
   loadMeshWorktreeBootstrapConfig: () => loadMeshWorktreeBootstrapConfig,
+  loadRepoMeshJsonConfig: () => loadRepoMeshJsonConfig,
   loadRepoSettings: () => loadRepoSettings,
   loadState: () => loadState,
   logCommand: () => logCommand,
@@ -30819,6 +30905,7 @@ __export(index_exports, {
   normalizeMeshWorkerResult: () => normalizeMeshWorkerResult,
   normalizeMessageParts: () => normalizeMessageParts,
   normalizeRepoIdentity: () => normalizeRepoIdentity,
+  normalizeRepoMeshDeclarativeConfig: () => normalizeRepoMeshDeclarativeConfig,
   normalizeSessionModalFields: () => normalizeSessionModalFields,
   parsePorcelainV2Status: () => parsePorcelainV2Status,
   parseProviderSourceConfigUpdate: () => parseProviderSourceConfigUpdate,
@@ -30889,6 +30976,7 @@ __export(index_exports, {
   runMeshWorktreeBootstrap: () => runMeshWorktreeBootstrap,
   saveConfig: () => saveConfig,
   saveState: () => saveState,
+  serializeMeshJsonConfigScaffold: () => serializeMeshJsonConfigScaffold,
   serializeV2EnvelopeToWire: () => serializeV2EnvelopeToWire,
   setDebugRuntimeConfig: () => setDebugRuntimeConfig,
   setLogLevel: () => setLogLevel,
@@ -31338,6 +31426,7 @@ function detectClaudeAskUserQuestionPromptFromJson(value, providerType = "claude
 
 // src/index.ts
 init_repo_mesh_types();
+init_mesh_json_config();
 
 // src/git/index.ts
 init_git_executor();
@@ -60653,6 +60742,139 @@ var meshCrudHandlers = {
       return { success: false, error: e.message };
     }
   },
+  // READ path for `.adhdev/mesh.json` — returns the currently-committed repo
+  // config (parsed + normalized) for a workspace so a UI can render/edit the
+  // existing declarative zones (notably `providerDefaults.autoApproveModes`)
+  // WITHOUT re-deriving them from the machine-local scaffold. Never writes.
+  // `config` is undefined when no repo file exists (sourceType 'unavailable') or
+  // it is unparseable (sourceType 'invalid', with the parse error surfaced).
+  read_mesh_json_config: async (_ctx, args) => {
+    const workspace = typeof args?.workspace === "string" && args.workspace.trim() ? args.workspace.trim() : process.cwd();
+    try {
+      const { loadRepoMeshJsonConfig: loadRepoMeshJsonConfig2 } = await Promise.resolve().then(() => (init_mesh_json_config(), mesh_json_config_exports));
+      const loaded = loadRepoMeshJsonConfig2(workspace);
+      return {
+        success: true,
+        workspace,
+        sourceType: loaded.sourceType,
+        source: loaded.source,
+        ...loaded.path ? { path: loaded.path } : {},
+        ...loaded.error ? { error: loaded.error } : {},
+        config: loaded.config,
+        // Convenience projection so the UI does not have to reach into config.
+        providerDefaults: loaded.config?.providerDefaults
+      };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  },
+  // Partial-edit WRITE path for `.adhdev/mesh.json` `providerDefaults` — a
+  // READ-MODIFY-WRITE that preserves operator hand-edits. Unlike
+  // write_mesh_json_config (which rebuilds the WHOLE file from the machine-local
+  // scaffold and can silently drop hand-edited zones), this parses the existing
+  // repo file, merges ONLY the providerDefaults.autoApproveModes zone, and
+  // re-serializes — coordinator prompt, operating notes and limits authored in
+  // the repo are carried through untouched. Defaults to dry-run.
+  //
+  // args: { workspace?, autoApproveModes: Record<providerType,modeId>, write?, merge? }
+  //   merge=true (default): per-provider merge into the existing map; a modeId of
+  //     '' | null removes that provider's entry. merge=false: REPLACE the whole
+  //     autoApproveModes map with the supplied one.
+  set_mesh_provider_defaults: async (_ctx, args) => {
+    const workspace = typeof args?.workspace === "string" && args.workspace.trim() ? args.workspace.trim() : process.cwd();
+    const write = args?.write === true;
+    const merge = args?.merge !== false;
+    const inputModes = args?.autoApproveModes;
+    if (inputModes !== void 0 && (typeof inputModes !== "object" || inputModes === null || Array.isArray(inputModes))) {
+      return { success: false, error: "autoApproveModes must be an object (providerType \u2192 modeId) when provided" };
+    }
+    try {
+      const {
+        loadRepoMeshJsonConfig: loadRepoMeshJsonConfig2,
+        normalizeRepoMeshDeclarativeConfig: normalizeRepoMeshDeclarativeConfig2,
+        MESH_JSON_CONFIG_LOCATIONS: MESH_JSON_CONFIG_LOCATIONS2
+      } = await Promise.resolve().then(() => (init_mesh_json_config(), mesh_json_config_exports));
+      const { existsSync: existsSync57, readFileSync: readFileSync44, mkdirSync: mkdirSync23, writeFileSync: writeFileSync25 } = await import("fs");
+      const { dirname: dirname19, join: join54 } = await import("path");
+      const yaml6 = await import("js-yaml");
+      const relativePath = MESH_JSON_CONFIG_LOCATIONS2[0];
+      let baseDoc = { version: 1 };
+      let existingPath = join54(workspace, relativePath);
+      let existedAsYaml = false;
+      for (const relative5 of MESH_JSON_CONFIG_LOCATIONS2) {
+        const candidate = join54(workspace, relative5);
+        if (!existsSync57(candidate)) continue;
+        try {
+          const text = readFileSync44(candidate, "utf-8");
+          const parsed = /\.json$/i.test(candidate) ? JSON.parse(text) : yaml6.load(text);
+          if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            baseDoc = parsed;
+            existingPath = candidate;
+            existedAsYaml = !/\.json$/i.test(candidate);
+          }
+        } catch (e) {
+          return { success: false, error: `existing ${relative5} is unparseable, refusing to overwrite: ${e?.message || e}` };
+        }
+        break;
+      }
+      const existingPd = baseDoc.providerDefaults && typeof baseDoc.providerDefaults === "object" && !Array.isArray(baseDoc.providerDefaults) ? baseDoc.providerDefaults : {};
+      const existingModes = existingPd.autoApproveModes && typeof existingPd.autoApproveModes === "object" && !Array.isArray(existingPd.autoApproveModes) ? { ...existingPd.autoApproveModes } : {};
+      const nextModes = merge ? existingModes : {};
+      if (inputModes) {
+        for (const [providerType, modeId] of Object.entries(inputModes)) {
+          const type = typeof providerType === "string" ? providerType.trim() : "";
+          if (!type) continue;
+          const id = typeof modeId === "string" ? modeId.trim() : "";
+          if (id) nextModes[type] = id;
+          else delete nextModes[type];
+        }
+      }
+      const nextDoc = { ...baseDoc, version: 1 };
+      if (Object.keys(nextModes).length) {
+        nextDoc.providerDefaults = { ...existingPd, autoApproveModes: nextModes };
+      } else {
+        if (nextDoc.providerDefaults) {
+          const { autoApproveModes, ...restPd } = nextDoc.providerDefaults;
+          if (Object.keys(restPd).length) nextDoc.providerDefaults = restPd;
+          else delete nextDoc.providerDefaults;
+        }
+      }
+      const validation = normalizeRepoMeshDeclarativeConfig2(nextDoc);
+      if (!validation.valid) {
+        return { success: false, error: `merged mesh.json is invalid: ${validation.errors.join("; ")}` };
+      }
+      const absolutePath = existingPath;
+      const serialized = existedAsYaml ? yaml6.dump(nextDoc, { indent: 2 }) : `${JSON.stringify(nextDoc, null, 2)}
+`;
+      if (!write) {
+        return {
+          success: true,
+          written: false,
+          dryRun: true,
+          path: absolutePath,
+          relativePath,
+          merge,
+          providerDefaults: nextDoc.providerDefaults,
+          preview: serialized,
+          note: "Dry-run: nothing written. Re-run with write=true to persist. Only the providerDefaults zone is merged; other repo zones are preserved."
+        };
+      }
+      mkdirSync23(dirname19(absolutePath), { recursive: true });
+      writeFileSync25(absolutePath, serialized, "utf-8");
+      return {
+        success: true,
+        written: true,
+        dryRun: false,
+        path: absolutePath,
+        relativePath,
+        merge,
+        providerDefaults: nextDoc.providerDefaults,
+        note: "Wrote providerDefaults into .adhdev/mesh.json (read-modify-write; other zones preserved). Commit it to the repo."
+      };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  },
   delete_mesh: async (_ctx, args) => {
     const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
     if (!meshId) return { success: false, error: "meshId required" };
@@ -76776,6 +76998,9 @@ var V1_CONTRACT_VERSION = "1.0.0";
   MAX_LEDGER_SLICE_LIMIT,
   MESH_CONVERGE_FAST_FORWARD_TAG,
   MESH_CONVERGE_REFINE_TAG,
+  MESH_JSON_CONFIG_LOCATIONS,
+  MESH_JSON_CONFIG_SCHEMA,
+  MESH_JSON_PROVIDER_DEFAULTS_EXAMPLE,
   MESH_MAX_PARALLEL_TASKS_MAX,
   MESH_MAX_PARALLEL_TASKS_MIN,
   MESH_MISSION_LIST_HISTORY_ID_LIMIT,
@@ -76835,6 +77060,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   buildMeshActiveWorkSummary,
   buildMeshAsyncRefineJobs,
   buildMeshHostRequiredFailure,
+  buildMeshJsonConfigScaffold,
   buildMeshLedgerReconciliationEvidence,
   buildMeshLedgerReplicaEvidence,
   buildMeshMagiActivity,
@@ -76999,6 +77225,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   loadMeshCoordinatorRegistry,
   loadMeshRefineConfig,
   loadMeshWorktreeBootstrapConfig,
+  loadRepoMeshJsonConfig,
   loadRepoSettings,
   loadState,
   logCommand,
@@ -77039,6 +77266,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   normalizeMeshWorkerResult,
   normalizeMessageParts,
   normalizeRepoIdentity,
+  normalizeRepoMeshDeclarativeConfig,
   normalizeSessionModalFields,
   parsePorcelainV2Status,
   parseProviderSourceConfigUpdate,
@@ -77109,6 +77337,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   runMeshWorktreeBootstrap,
   saveConfig,
   saveState,
+  serializeMeshJsonConfigScaffold,
   serializeV2EnvelopeToWire,
   setDebugRuntimeConfig,
   setLogLevel,