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

package/dist/index.mjs

@@ -179,7 +179,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;
@@ -189,14 +189,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") {
@@ -204,8 +207,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 };
 }
@@ -305,6 +308,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
+});
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import * as yaml from "js-yaml";
+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 = join(base, relative5);
+      if (!existsSync(configPath)) continue;
+      try {
+        const parsed = parseConfigText(configPath, 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 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";
+    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, {
@@ -521,10 +785,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;
 }
@@ -536,17 +800,17 @@ var init_build_info = __esm({
 });
 
 // src/git/change-impact-config.ts
-import { existsSync, readdirSync, readFileSync, statSync } from "fs";
-import { join } from "path";
-import * as yaml from "js-yaml";
-function isRecord(value) {
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { join as join2 } from "path";
+import * as yaml2 from "js-yaml";
+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;
   }
@@ -562,7 +826,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 = {};
@@ -579,7 +843,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 = {};
@@ -601,23 +865,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 = join(repoRoot, relative5);
-    if (!existsSync(configPath)) continue;
+    const configPath = join2(repoRoot, relative5);
+    if (!existsSync2(configPath)) continue;
     try {
-      const text = readFileSync(configPath, "utf-8");
+      const text = readFileSync2(configPath, "utf-8");
       let mtimeMs = 0;
       try {
         mtimeMs = 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 {
@@ -686,10 +950,10 @@ function suggestChangeImpactConfig(repoRoot) {
   const daemon = /* @__PURE__ */ new Set();
   const web = /* @__PURE__ */ new Set();
   const unclassified = [];
-  const roots = ["packages", join("oss", "packages")];
+  const roots = ["packages", join2("oss", "packages")];
   for (const rel of roots) {
-    const packagesRoot = join(repoRoot, rel);
-    if (!existsSync(packagesRoot)) continue;
+    const packagesRoot = join2(repoRoot, rel);
+    if (!existsSync2(packagesRoot)) continue;
     for (const name of listPackageDirs(packagesRoot)) {
       if (/(^web[-.]|[-.]web$)/i.test(name) || /dashboard|frontend|ui$/i.test(name)) {
         web.add(name);
@@ -777,7 +1041,7 @@ var init_change_impact_config = __esm({
 });
 
 // src/git/git-status.ts
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 function statusCacheKey(workspace, options) {
   const includeSubmodules = options.includeSubmodules !== false;
   const refreshUpstream = options.refreshUpstream === true;
@@ -960,7 +1224,7 @@ async function refineVerdictThroughSubmodules(repoPath, fromRef, toRef, options,
     }
     let subVerdict;
     try {
-      subVerdict = await classifyChangedPackages(join2(repoPath, subPath), range.from, range.to, {
+      subVerdict = await classifyChangedPackages(join3(repoPath, subPath), range.from, range.to, {
         ...options,
         // Do not force the root's injected config onto the submodule — let it resolve
         // its own .adhdev/change-impact.* (or fall back to defaults).
@@ -1725,8 +1989,8 @@ __export(config_exports, {
   updateConfig: () => updateConfig
 });
 import { homedir } from "os";
-import { join as join3 } from "path";
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync, chmodSync } from "fs";
+import { join as join4 } from "path";
+import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync3, writeFileSync, chmodSync } from "fs";
 import { randomUUID } from "crypto";
 function resolveProviderSourceMode(providerSourceMode, legacyDisableUpstream) {
   if (providerSourceMode === "normal" || providerSourceMode === "no-upstream") {
@@ -1823,25 +2087,25 @@ function ensureMachineId(config) {
 }
 function getConfigDir() {
   const override = process.env.ADHDEV_CONFIG_DIR;
-  const dir = override && override.trim() ? override.trim() : join3(homedir(), ".adhdev");
-  if (!existsSync2(dir)) {
+  const dir = override && override.trim() ? override.trim() : join4(homedir(), ".adhdev");
+  if (!existsSync3(dir)) {
     mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
 function getDaemonDataDir() {
-  const dir = join3(getConfigDir(), "daemon");
-  if (!existsSync2(dir)) {
+  const dir = join4(getConfigDir(), "daemon");
+  if (!existsSync3(dir)) {
     mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
 function getConfigPath() {
-  return join3(getConfigDir(), "config.json");
+  return join4(getConfigDir(), "config.json");
 }
 function migrateStateToStateFile(raw) {
-  const statePath = join3(getConfigDir(), "state.json");
-  if (existsSync2(statePath)) return;
+  const statePath = join4(getConfigDir(), "state.json");
+  if (existsSync3(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 : {};
@@ -1865,7 +2129,7 @@ function migrateStateToStateFile(raw) {
 }
 function loadConfig() {
   const configPath = getConfigPath();
-  if (!existsSync2(configPath)) {
+  if (!existsSync3(configPath)) {
     const initialized = ensureMachineId({ ...DEFAULT_CONFIG });
     try {
       saveConfig(initialized.config);
@@ -1874,7 +2138,7 @@ function loadConfig() {
     return initialized.config;
   }
   try {
-    const raw = readFileSync2(configPath, "utf-8");
+    const raw = readFileSync3(configPath, "utf-8");
     const parsed = JSON.parse(raw);
     migrateStateToStateFile(parsed);
     const normalizedInput = normalizeConfig(parsed);
@@ -1896,7 +2160,7 @@ function saveConfig(config) {
   const configPath = getConfigPath();
   const dir = getConfigDir();
   const normalized = normalizeConfig(config);
-  if (!existsSync2(dir)) {
+  if (!existsSync3(dir)) {
     mkdirSync(dir, { recursive: true, mode: 448 });
   }
   writeFileSync(configPath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
@@ -1972,7 +2236,7 @@ __export(git_worktree_exports, {
 });
 import * as path4 from "path";
 import { mkdir } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
 function resolveWorktreePath(repoRoot, meshName, branch) {
@@ -2065,7 +2329,7 @@ async function createWorktree(opts) {
   const { repoRoot, branch, baseBranch, meshName } = opts;
   const remote = (opts.remote || "origin").trim() || "origin";
   const targetDir = opts.targetDir || resolveWorktreePath(repoRoot, meshName, branch);
-  if (existsSync3(targetDir)) {
+  if (existsSync4(targetDir)) {
     throw new Error(`Worktree target directory already exists: ${targetDir}`);
   }
   await mkdir(path4.dirname(targetDir), { recursive: true });
@@ -2090,7 +2354,7 @@ async function createWorktree(opts) {
   } catch (error) {
     const stderr = typeof error.stderr === "string" ? error.stderr : "";
     if (/already exists/i.test(stderr)) {
-      if (existsSync3(targetDir)) {
+      if (existsSync4(targetDir)) {
         throw new Error(`Worktree target directory was created concurrently: ${targetDir}`);
       }
       throw new Error(`Branch '${branch}' already exists or is checked out in another worktree`);
@@ -2105,7 +2369,7 @@ async function createWorktree(opts) {
   };
 }
 async function removeWorktree(repoRoot, worktreePath, opts = {}) {
-  if (!existsSync3(worktreePath)) {
+  if (!existsSync4(worktreePath)) {
     await pruneWorktrees(repoRoot);
     return { success: true, removedPath: worktreePath };
   }
@@ -3360,17 +3624,17 @@ __export(mesh_config_exports, {
   updateMesh: () => updateMesh,
   updateNode: () => updateNode
 });
-import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { join as join7 } from "path";
 import { randomBytes, randomUUID as randomUUID3 } from "crypto";
 function getMeshConfigPath() {
-  return join6(getConfigDir(), "meshes.json");
+  return join7(getConfigDir(), "meshes.json");
 }
 function loadMeshConfig() {
   const path46 = getMeshConfigPath();
-  if (!existsSync5(path46)) return { meshes: [] };
+  if (!existsSync6(path46)) return { meshes: [] };
   try {
-    const raw = JSON.parse(readFileSync3(path46, "utf-8"));
+    const raw = JSON.parse(readFileSync4(path46, "utf-8"));
     if (!raw || !Array.isArray(raw.meshes)) return { meshes: [] };
     const config = raw;
     const migrated = migrateLoadedMeshConfig(config);
@@ -4974,8 +5238,8 @@ var init_contracts = __esm({
 });
 
 // src/mesh/mesh-events-pending.ts
-import { appendFileSync, existsSync as existsSync7, readFileSync as readFileSync4, renameSync as renameSync2, statSync as statSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
-import { join as join8 } from "path";
+import { appendFileSync, existsSync as existsSync8, readFileSync as readFileSync5, renameSync as renameSync2, statSync as statSync4, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
+import { join as join9 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 function normalizeCoordinatorDaemonIds(coordinatorDaemonId) {
   return expandDaemonIdForms(coordinatorDaemonId);
@@ -5198,9 +5462,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 join8(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
+    return join9(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
   }
-  return join8(getLedgerDir(), `${safe}.pending-events.jsonl`);
+  return join9(getLedgerDir(), `${safe}.pending-events.jsonl`);
 }
 function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
   if (!meshId) return [];
@@ -5209,9 +5473,9 @@ function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
   const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   const events = [];
   for (const path46 of paths) {
-    if (!existsSync7(path46)) continue;
+    if (!existsSync8(path46)) continue;
     try {
-      const raw = readFileSync4(path46, "utf-8");
+      const raw = readFileSync5(path46, "utf-8");
       const parsed = raw.split("\n").filter(Boolean).flatMap((line) => {
         try {
           return [JSON.parse(line)];
@@ -5301,9 +5565,9 @@ function prunePendingMeshCoordinatorEventsRetention() {
 }
 function trimPendingEventsIfNeeded(path46) {
   try {
-    if (!existsSync7(path46)) return;
+    if (!existsSync8(path46)) return;
     if (statSync4(path46).size <= MAX_PENDING_EVENTS_BYTES) return;
-    const lines = readFileSync4(path46, "utf-8").split("\n").filter(Boolean);
+    const lines = readFileSync5(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) {
@@ -5470,7 +5734,7 @@ function atomicDrainFile(path46) {
     return null;
   }
   try {
-    const content = readFileSync4(tmpPath, "utf-8");
+    const content = readFileSync5(tmpPath, "utf-8");
     try {
       unlinkSync2(tmpPath);
     } catch {
@@ -5493,7 +5757,7 @@ function selectiveDrainFile(path46, predicate) {
   }
   let content;
   try {
-    content = readFileSync4(tmpPath, "utf-8");
+    content = readFileSync5(tmpPath, "utf-8");
   } catch {
     try {
       unlinkSync2(tmpPath);
@@ -5524,7 +5788,7 @@ function selectiveDrainFile(path46, predicate) {
     unlinkSync2(tmpPath);
   } catch {
     try {
-      if (existsSync7(tmpPath) && !existsSync7(path46)) renameSync2(tmpPath, path46);
+      if (existsSync8(tmpPath) && !existsSync8(path46)) renameSync2(tmpPath, path46);
     } catch {
     }
     return [];
@@ -5752,7 +6016,7 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   }
   const paths = coordinatorDaemonId ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   for (const path46 of paths) {
-    if (existsSync7(path46)) try {
+    if (existsSync8(path46)) try {
       unlinkSync2(path46);
     } catch {
     }
@@ -7102,8 +7366,8 @@ var init_mesh_work_queue = __esm({
 });
 
 // src/mesh/mesh-runtime-store.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync5, renameSync as renameSync3, statSync as statSync5, unlinkSync as unlinkSync3 } from "fs";
-import { dirname as dirname2, join as join9 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync6, renameSync as renameSync3, statSync as statSync5, unlinkSync as unlinkSync3 } from "fs";
+import { dirname as dirname2, join as join10 } from "path";
 function loadDatabaseCtor() {
   if (DatabaseCtor) return DatabaseCtor;
   DatabaseCtor = loadBetterSqlite3();
@@ -7113,13 +7377,13 @@ function safeMeshId(meshId) {
   return meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function legacyQueuePath(meshId) {
-  return join9(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
+  return join10(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
 }
 function cleanupStrayRootRuntimeDb(canonicalPath) {
   try {
-    const strayPath = join9(getConfigDir(), "mesh-runtime.db");
+    const strayPath = join10(getConfigDir(), "mesh-runtime.db");
     if (strayPath === canonicalPath) return;
-    if (!existsSync8(strayPath)) return;
+    if (!existsSync9(strayPath)) return;
     if (statSync5(strayPath).size !== 0) return;
     unlinkSync3(strayPath);
     if (!loggedStrayCleanup) {
@@ -7135,16 +7399,16 @@ function cleanupStrayRootRuntimeDb(canonicalPath) {
 }
 function meshRuntimeStorePath() {
   const dir = getLedgerDir();
-  const nextPath = join9(dir, "mesh-runtime.db");
+  const nextPath = join10(dir, "mesh-runtime.db");
   cleanupStrayRootRuntimeDb(nextPath);
-  if (existsSync8(nextPath)) return nextPath;
-  const legacyPath = join9(dir, "beads.db");
-  if (!existsSync8(legacyPath)) return nextPath;
+  if (existsSync9(nextPath)) return nextPath;
+  const legacyPath = join10(dir, "beads.db");
+  if (!existsSync9(legacyPath)) return nextPath;
   try {
     renameSync3(legacyPath, nextPath);
     for (const suffix of ["-wal", "-shm"]) {
       const legacyCompanion = `${legacyPath}${suffix}`;
-      if (existsSync8(legacyCompanion)) {
+      if (existsSync9(legacyCompanion)) {
         renameSync3(legacyCompanion, `${nextPath}${suffix}`);
       }
     }
@@ -7156,7 +7420,7 @@ function meshRuntimeStorePath() {
         `Legacy beads.db\u2192mesh-runtime.db migration failed; using existing DB in-place to avoid data loss: ${err?.message || err}`
       );
     }
-    return existsSync8(nextPath) ? nextPath : legacyPath;
+    return existsSync9(nextPath) ? nextPath : legacyPath;
   }
   return nextPath;
 }
@@ -7210,7 +7474,7 @@ var init_mesh_runtime_store = __esm({
       // 50 MB
       constructor(dbPath) {
         const dir = dirname2(dbPath);
-        if (!existsSync8(dir)) mkdirSync4(dir, { recursive: true });
+        if (!existsSync9(dir)) mkdirSync4(dir, { recursive: true });
         this.dbPath = dbPath;
         this.db = new (loadDatabaseCtor())(dbPath);
         this.db.pragma("journal_mode = WAL");
@@ -7589,7 +7853,7 @@ var init_mesh_runtime_store = __esm({
         this.walWriteCounter = 0;
         try {
           const walPath = `${this.dbPath}-wal`;
-          if (!existsSync8(walPath)) return;
+          if (!existsSync9(walPath)) return;
           const size = statSync5(walPath).size;
           if (size < _MeshRuntimeStore.WAL_MAX_BYTES) return;
           process.stderr.write(
@@ -7606,9 +7870,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 (!existsSync8(path46)) return;
+        if (!existsSync9(path46)) return;
         try {
-          const entries = JSON.parse(readFileSync5(path46, "utf-8"));
+          const entries = JSON.parse(readFileSync6(path46, "utf-8"));
           if (!Array.isArray(entries)) return;
           const insert = this.db.prepare(`
                 INSERT OR REPLACE INTO mesh_queue (
@@ -9039,8 +9303,8 @@ __export(mesh_ledger_exports, {
   readOperatingNotes: () => readOperatingNotes,
   tombstoneOperatingNote: () => tombstoneOperatingNote
 });
-import { appendFileSync as appendFileSync2, existsSync as existsSync9, mkdirSync as mkdirSync5, readFileSync as readFileSync6, statSync as statSync6, renameSync as renameSync4, writeFileSync as writeFileSync4 } from "fs";
-import { join as join10 } from "path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync5, readFileSync as readFileSync7, statSync as statSync6, renameSync as renameSync4, writeFileSync as writeFileSync4 } from "fs";
+import { join as join11 } from "path";
 import { randomUUID as randomUUID8 } from "crypto";
 import { EventEmitter } from "events";
 function isIntentionalCleanupStopEntry(entry) {
@@ -9063,35 +9327,35 @@ function isNoteExpired(note, now) {
   return now - created >= ttlDays * MS_PER_DAY;
 }
 function getLedgerDir() {
-  const dir = join10(getConfigDir(), LEDGER_DIR_NAME);
-  if (!existsSync9(dir)) {
+  const dir = join11(getConfigDir(), LEDGER_DIR_NAME);
+  if (!existsSync10(dir)) {
     mkdirSync5(dir, { recursive: true, mode: 448 });
   }
   return dir;
 }
 function getLedgerPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join10(getLedgerDir(), `${safe}.jsonl`);
+  return join11(getLedgerDir(), `${safe}.jsonl`);
 }
 function getRotatedPath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join10(getLedgerDir(), `${safe}.${index}.jsonl`);
+  return join11(getLedgerDir(), `${safe}.${index}.jsonl`);
 }
 function getArchivePath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join10(getLedgerDir(), `${safe}.archive.jsonl`);
+  return join11(getLedgerDir(), `${safe}.archive.jsonl`);
 }
 function getRotatedArchivePath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join10(getLedgerDir(), `${safe}.archive.${index}.jsonl`);
+  return join11(getLedgerDir(), `${safe}.archive.${index}.jsonl`);
 }
 function getArchivedCountsPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join10(getLedgerDir(), `${safe}.archived-counts.json`);
+  return join11(getLedgerDir(), `${safe}.archived-counts.json`);
 }
 function rotateArchiveFile(meshId, archivePath) {
   let index = 1;
-  while (existsSync9(getRotatedArchivePath(meshId, index))) {
+  while (existsSync10(getRotatedArchivePath(meshId, index))) {
     index++;
     if (index > 5) break;
   }
@@ -9105,9 +9369,9 @@ function rotateArchiveFile(meshId, archivePath) {
 }
 function readArchivedCounts(meshId) {
   const path46 = getArchivedCountsPath(meshId);
-  if (!existsSync9(path46)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
+  if (!existsSync10(path46)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
   try {
-    return JSON.parse(readFileSync6(path46, "utf-8"));
+    return JSON.parse(readFileSync7(path46, "utf-8"));
   } catch {
     return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
   }
@@ -9146,7 +9410,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
 }
 function compactLedger(meshId) {
   const filePath = getLedgerPath(meshId);
-  if (!existsSync9(filePath)) return { archivedCount: 0, retainedCount: 0 };
+  if (!existsSync10(filePath)) return { archivedCount: 0, retainedCount: 0 };
   const cutoff = Date.now() - ARCHIVE_TERMINAL_OLDER_THAN_MS;
   const entries = readLedgerEntries(meshId);
   const keep = [];
@@ -9161,7 +9425,7 @@ function compactLedger(meshId) {
   if (archive.length === 0) return { archivedCount: 0, retainedCount: keep.length };
   const archivePath = getArchivePath(meshId);
   try {
-    if (existsSync9(archivePath) && statSync6(archivePath).size > 50 * 1024 * 1024) {
+    if (existsSync10(archivePath) && statSync6(archivePath).size > 50 * 1024 * 1024) {
       rotateArchiveFile(meshId, archivePath);
     }
     const archiveLines = archive.map((e) => JSON.stringify(e)).join("\n") + "\n";
@@ -9352,7 +9616,7 @@ function appendLedgerEntry(meshId, partial) {
     ...partial
   };
   const filePath = getLedgerPath(meshId);
-  if (existsSync9(filePath)) {
+  if (existsSync10(filePath)) {
     try {
       const stat2 = statSync6(filePath);
       if (stat2.size >= MAX_FILE_SIZE_BYTES) {
@@ -9540,10 +9804,10 @@ function appendRemoteLedgerEntries(meshId, entries) {
 }
 function readLedgerFile(meshId) {
   const filePath = getLedgerPath(meshId);
-  if (!existsSync9(filePath)) return [];
+  if (!existsSync10(filePath)) return [];
   let content;
   try {
-    content = readFileSync6(filePath, "utf-8");
+    content = readFileSync7(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -9808,7 +10072,7 @@ function getSessionRecoveryContext(meshId, opts) {
 }
 function rotateLedgerFile(meshId, currentPath) {
   let index = 1;
-  while (existsSync9(getRotatedPath(meshId, index))) {
+  while (existsSync10(getRotatedPath(meshId, index))) {
     index++;
     if (index > 10) break;
   }
@@ -10813,10 +11077,10 @@ __export(mesh_coordinator_exports, {
   resolveMeshCoordinatorSetup: () => resolveMeshCoordinatorSetup,
   stripCoordinatorWrapperFile: () => stripCoordinatorWrapperFile
 });
-import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync5 } from "fs";
 import * as os4 from "os";
 import { DEFAULT_SESSION_HOST_COLS, DEFAULT_SESSION_HOST_ROWS } from "@adhdev/session-host-core";
-import { basename as basename2, isAbsolute as isAbsolute4, join as join12, resolve as resolve7 } from "path";
+import { basename as basename2, isAbsolute as isAbsolute4, join as join13, resolve as resolve7 } from "path";
 function isHermesProvider(provider, cliType) {
   const type = cliType?.trim() || provider?.type?.trim() || "";
   return type === HERMES_CLI_TYPE;
@@ -10836,7 +11100,7 @@ function resolveHermesMeshCoordinatorSetup(options) {
       reason: "Could not resolve the ADHDev MCP server entrypoint and a Node runtime with WebSocket support for daemon IPC mode"
     };
   }
-  const configPath = join12(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
+  const configPath = join13(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
   if (!configPath.trim()) {
     return createHermesManualMeshCoordinatorSetup(options.meshId, options.workspace);
   }
@@ -10983,14 +11247,14 @@ function resolveHermesCoordinatorHome(meshId, workspace) {
   const key2 = `${meshId || "mesh"}
 ${resolve7(workspace || os4.tmpdir())}`;
   const hash = shortHash(key2);
-  return join12(os4.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
+  return join13(os4.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
 }
 function resolveMcpConfigPath(configPath, workspace) {
   const trimmed = configPath.trim();
   if (trimmed === "~") return os4.homedir();
-  if (trimmed.startsWith("~/")) return join12(os4.homedir(), trimmed.slice(2));
+  if (trimmed.startsWith("~/")) return join13(os4.homedir(), trimmed.slice(2));
   if (isAbsolute4(trimmed)) return trimmed;
-  return join12(workspace, trimmed);
+  return join13(workspace, trimmed);
 }
 function resolveAdhdevMcpServerLaunch(options) {
   const directEntryPath = resolveAdhdevMcpEntryPath(options.adhdevMcpEntryPath);
@@ -11061,7 +11325,7 @@ function applyInjectionRule(systemPrompt, injection, ctx) {
     }
     case "context_file": {
       if (!injection.path) return {};
-      const target = isAbsolute4(injection.path) ? injection.path : join12(ctx.workspace, injection.path);
+      const target = isAbsolute4(injection.path) ? injection.path : join13(ctx.workspace, injection.path);
       const wrapper = injection.wrapper && injection.wrapper.includes("{prompt}") ? injection.wrapper : "{prompt}";
       const managedNote = "> _Managed by adhdev mesh coordinator \u2014 do not hand-edit this block. Changes inside the sentinels are overwritten on next coordinator launch._";
       const promptWithNote = `${managedNote}
@@ -11070,8 +11334,8 @@ ${systemPrompt}`;
       const rendered = wrapper.replace(/\{prompt\}/g, promptWithNote);
       const sentinel = wrapper.split("{prompt}")[0].trim();
       try {
-        if (existsSync10(target)) {
-          const existing = readFileSync8(target, "utf-8");
+        if (existsSync11(target)) {
+          const existing = readFileSync9(target, "utf-8");
           if (sentinel && existing.includes(sentinel)) {
             const closing = wrapper.split("{prompt}")[1]?.trim();
             const safeOpen = sentinel.replace(/[.+^${}()|[\]\\]/g, "\\$&");
@@ -11101,8 +11365,8 @@ function stripCoordinatorWrapperFile(filePath) {
   const OPEN = "<!-- adhdev-mesh-coordinator-prompt -->";
   const CLOSE = "<!-- /adhdev-mesh-coordinator-prompt -->";
   try {
-    if (!existsSync10(filePath)) return;
-    const existing = readFileSync8(filePath, "utf-8");
+    if (!existsSync11(filePath)) return;
+    const existing = readFileSync9(filePath, "utf-8");
     const openIdx = existing.indexOf(OPEN);
     if (openIdx < 0) return;
     const closeIdx = existing.indexOf(CLOSE, openIdx);
@@ -11205,16 +11469,16 @@ var init_mesh_coordinator = __esm({
 });
 
 // src/mesh/coordinator-registry.ts
-import { join as join13 } from "path";
-import { existsSync as existsSync11, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { join as join14 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
 function getRegistryPath() {
-  return join13(getDaemonDataDir(), "mesh-coordinators.json");
+  return join14(getDaemonDataDir(), "mesh-coordinators.json");
 }
 function loadMeshCoordinatorRegistry() {
   const path46 = getRegistryPath();
-  if (!existsSync11(path46)) return;
+  if (!existsSync12(path46)) return;
   try {
-    const raw = JSON.parse(readFileSync9(path46, "utf-8"));
+    const raw = JSON.parse(readFileSync10(path46, "utf-8"));
     if (!Array.isArray(raw)) return;
     _registry.clear();
     for (const entry of raw) {
@@ -11270,9 +11534,9 @@ var init_coordinator_registry = __esm({
 });
 
 // src/mesh/refine-config.ts
-import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
-import { join as join14 } from "path";
-import * as yaml2 from "js-yaml";
+import { existsSync as existsSync13, readFileSync as readFileSync11 } from "fs";
+import { join as join15 } from "path";
+import * as yaml3 from "js-yaml";
 function isMeshConfigRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -11356,14 +11620,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;
@@ -11371,8 +11635,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) {
@@ -11395,9 +11659,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 : {};
@@ -11408,10 +11672,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 = join14(workspace, relative5);
-    if (!existsSync12(configPath)) continue;
+    const configPath = join15(workspace, relative5);
+    if (!existsSync13(configPath)) continue;
     try {
-      const parsed = parseConfigText2(configPath, readFileSync10(configPath, "utf-8"));
+      const parsed = parseConfigText3(configPath, readFileSync11(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 };
@@ -11427,20 +11691,20 @@ function loadMeshRefineConfig(mesh, workspace) {
 }
 function readPackageScripts(workspace) {
   try {
-    const parsed = JSON.parse(readFileSync10(join14(workspace, "package.json"), "utf-8"));
-    return isRecord2(parsed?.scripts) ? parsed.scripts : {};
+    const parsed = JSON.parse(readFileSync11(join15(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;
@@ -11502,7 +11766,7 @@ function resolveMeshRefineValidationPlan(mesh, workspace) {
     unavailableReason: validation.commands.length ? void 0 : "validation_unavailable: repo mesh/refine config has no validation.commands"
   };
 }
-var 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 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";
@@ -11596,13 +11860,13 @@ 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;
   }
 });
 
 // src/cli-adapters/resolve-executable.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import * as path10 from "path";
 function resolveWin32GlobalBin(trimmed) {
   if (path10.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\")) {
@@ -11618,7 +11882,7 @@ function resolveWin32GlobalBin(trimmed) {
     if (!dir) continue;
     for (const ext of WIN_EXEC_EXT) {
       const full = path10.join(dir, trimmed + ext);
-      if (existsSync13(full)) return full;
+      if (existsSync14(full)) return full;
     }
   }
   return null;
@@ -11635,7 +11899,7 @@ function resolveWin32Executable(command) {
   if (process.platform !== "win32") return command;
   const trimmed = (command || "").trim();
   if (!trimmed) return command;
-  if (path10.isAbsolute(trimmed) && existsSync13(trimmed)) return trimmed;
+  if (path10.isAbsolute(trimmed) && existsSync14(trimmed)) return trimmed;
   try {
     const out = execFileSync("where", [trimmed], {
       encoding: "utf8",
@@ -11711,12 +11975,12 @@ __export(worktree_bootstrap_config_exports, {
   shouldDeferDispatchForBootstrap: () => shouldDeferDispatchForBootstrap,
   validateMeshWorktreeBootstrapConfig: () => validateMeshWorktreeBootstrapConfig
 });
-import { existsSync as existsSync14, readFileSync as readFileSync11 } from "fs";
-import { join as join16, resolve as pathResolve } from "path";
+import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
+import { join as join17, resolve as pathResolve } from "path";
 import { execFile as execFile3, execFileSync as execFileSync2 } from "child_process";
 import { createHash as createHash2 } from "crypto";
 import { promisify as promisify3 } from "util";
-import * as yaml3 from "js-yaml";
+import * as yaml4 from "js-yaml";
 function getRegisteredSubmodulePaths(workspace) {
   const paths = /* @__PURE__ */ new Set();
   try {
@@ -11831,7 +12095,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 || !existsSync14(workspace)) return false;
+  if (!workspace || !existsSync15(workspace)) return false;
   try {
     const out = execFileSync2(resolveWin32Executable("git"), ["status", "--porcelain"], {
       cwd: workspace,
@@ -11852,9 +12116,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);
@@ -11894,10 +12158,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 = join16(workspace, relative5);
-    if (!existsSync14(configPath)) continue;
+    const configPath = join17(workspace, relative5);
+    if (!existsSync15(configPath)) continue;
     try {
-      const parsed = parseConfigText3(configPath, readFileSync11(configPath, "utf-8"));
+      const parsed = parseConfigText4(configPath, readFileSync12(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 };
@@ -11910,9 +12174,9 @@ function loadMeshWorktreeBootstrapConfig(mesh, workspace) {
 function computeStaleInputsDigest(workspace, staleInputs) {
   const digest = {};
   for (const relative5 of staleInputs ?? []) {
-    const filePath = join16(workspace, relative5);
+    const filePath = join17(workspace, relative5);
     try {
-      digest[relative5] = createHash2("sha256").update(readFileSync11(filePath)).digest("hex");
+      digest[relative5] = createHash2("sha256").update(readFileSync12(filePath)).digest("hex");
     } catch {
       digest[relative5] = "absent";
     }
@@ -11983,10 +12247,10 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
     staleInputs: loaded.config.staleInputs
   };
   const staleInputPaths = loaded.config.staleInputs ?? [];
-  const initiallyAbsent = staleInputPaths.filter((p) => !existsSync14(join16(workspace, p)));
+  const initiallyAbsent = staleInputPaths.filter((p) => !existsSync15(join17(workspace, p)));
   for (const command of validation.commands) {
     if (initiallyAbsent.length > 0) {
-      const appearedNow = initiallyAbsent.filter((p) => existsSync14(join16(workspace, p)));
+      const appearedNow = initiallyAbsent.filter((p) => existsSync15(join17(workspace, p)));
       if (appearedNow.length > 0) {
         state.status = "stale";
         state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -12109,224 +12373,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
-});
-import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
-import { join as join17 } from "path";
-import * as yaml4 from "js-yaml";
-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 = join17(base, relative5);
-      if (!existsSync15(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 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() : "";
@@ -16660,6 +16706,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);
@@ -16922,7 +16978,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
@@ -17361,10 +17419,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();
@@ -17377,6 +17435,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;
   });
 }
@@ -17657,7 +17721,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;
       }
@@ -17700,7 +17764,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
@@ -18165,6 +18231,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();
@@ -21723,7 +21790,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
                 }
@@ -22114,6 +22194,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();
@@ -30909,6 +30990,7 @@ function detectClaudeAskUserQuestionPromptFromJson(value, providerType = "claude
 
 // src/index.ts
 init_repo_mesh_types();
+init_mesh_json_config();
 
 // src/git/index.ts
 init_git_executor();
@@ -60229,6 +60311,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" };
@@ -76361,6 +76576,9 @@ export {
   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,
@@ -76420,6 +76638,7 @@ export {
   buildMeshActiveWorkSummary,
   buildMeshAsyncRefineJobs,
   buildMeshHostRequiredFailure,
+  buildMeshJsonConfigScaffold,
   buildMeshLedgerReconciliationEvidence,
   buildMeshLedgerReplicaEvidence,
   buildMeshMagiActivity,
@@ -76584,6 +76803,7 @@ export {
   loadMeshCoordinatorRegistry,
   loadMeshRefineConfig,
   loadMeshWorktreeBootstrapConfig,
+  loadRepoMeshJsonConfig,
   loadRepoSettings,
   loadState,
   logCommand,
@@ -76624,6 +76844,7 @@ export {
   normalizeMeshWorkerResult,
   normalizeMessageParts,
   normalizeRepoIdentity,
+  normalizeRepoMeshDeclarativeConfig,
   normalizeSessionModalFields,
   parsePorcelainV2Status,
   parseProviderSourceConfigUpdate,
@@ -76694,6 +76915,7 @@ export {
   runMeshWorktreeBootstrap,
   saveConfig,
   saveState,
+  serializeMeshJsonConfigScaffold,
   serializeV2EnvelopeToWire,
   setDebugRuntimeConfig,
   setLogLevel,