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

package/dist/index.js

@@ -36,14 +36,6 @@ function normalizeMeshSchedulingStrategy(value) {
   const trimmed = value.trim();
   return MESH_SCHEDULING_STRATEGIES.includes(trimmed) ? trimmed : DEFAULT_MESH_SCHEDULING_STRATEGY;
 }
-function normalizeMeshDistribution(value) {
-  if (typeof value !== "string") return DEFAULT_MESH_DISTRIBUTION;
-  const trimmed = value.trim();
-  return MESH_DISTRIBUTIONS.includes(trimmed) ? trimmed : DEFAULT_MESH_DISTRIBUTION;
-}
-function distributionToStrategy(distribution) {
-  return distribution === "spread" ? "least_loaded" : "first_eligible";
-}
 function resolveNodeSchedulingPriority(nodePolicy) {
   const raw = Number(nodePolicy?.schedulingPriority);
   return Number.isFinite(raw) ? raw : 0;
@@ -130,7 +122,7 @@ function resolveProviderMaxParallel(nodePolicy, providerType) {
   }
   return void 0;
 }
-var MESH_SCHEDULING_STRATEGIES, DEFAULT_MESH_SCHEDULING_STRATEGY, MESH_DISTRIBUTIONS, DEFAULT_MESH_DISTRIBUTION, MESH_CONVERGE_REFINE_TAG, MESH_CONVERGE_FAST_FORWARD_TAG, DEFAULT_MESH_POLICY, SESSION_CLEANUP_MODES, SPAWNED_SESSION_VISIBILITY_MODES, DIRTY_WORKSPACE_BEHAVIORS, MESH_MAX_PARALLEL_TASKS_MIN, MESH_MAX_PARALLEL_TASKS_MAX, DEFAULT_MESH_READONLY_MULTIPLIER;
+var MESH_SCHEDULING_STRATEGIES, DEFAULT_MESH_SCHEDULING_STRATEGY, MESH_CONVERGE_REFINE_TAG, MESH_CONVERGE_FAST_FORWARD_TAG, DEFAULT_MESH_POLICY, SESSION_CLEANUP_MODES, SPAWNED_SESSION_VISIBILITY_MODES, DIRTY_WORKSPACE_BEHAVIORS, MESH_MAX_PARALLEL_TASKS_MIN, MESH_MAX_PARALLEL_TASKS_MAX, DEFAULT_MESH_READONLY_MULTIPLIER;
 var init_repo_mesh_types = __esm({
   "src/repo-mesh-types.ts"() {
     "use strict";
@@ -141,8 +133,6 @@ var init_repo_mesh_types = __esm({
       "priority_only"
     ];
     DEFAULT_MESH_SCHEDULING_STRATEGY = "first_eligible";
-    MESH_DISTRIBUTIONS = ["spread", "in_order"];
-    DEFAULT_MESH_DISTRIBUTION = "spread";
     MESH_CONVERGE_REFINE_TAG = "converge=refine";
     MESH_CONVERGE_FAST_FORWARD_TAG = "converge=fast_forward";
     DEFAULT_MESH_POLICY = {
@@ -399,10 +389,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "69cd9c459ec9efafe19a05f66899bb791d6e0561" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "69cd9c45" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.411" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-28T09:11:20.391Z" : void 0);
+  const commit = readInjected(true ? "f8bbe838081c3b3e14df690b3ed24568979f635e" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "f8bbe838" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.412" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-28T10:27:03.423Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -7098,6 +7088,9 @@ __export(mesh_missions_exports, {
   summarizeMissionTasks: () => summarizeMissionTasks,
   upsertMeshMission: () => upsertMeshMission
 });
+function summarizeGoalForLedger(goal) {
+  return goal.length > LEDGER_GOAL_SUMMARY_MAX ? goal.slice(0, LEDGER_GOAL_SUMMARY_MAX) : goal;
+}
 function normalizeMissionStatus(value) {
   return MESH_MISSION_STATUSES.includes(value) ? value : "active";
 }
@@ -7110,6 +7103,8 @@ function upsertMeshMission(meshId, input) {
   const id = typeof input.id === "string" && input.id.trim() ? input.id.trim() : (0, import_crypto7.randomUUID)();
   const store = MeshRuntimeStore.getInstance();
   const existing = store.getMission(meshId, id);
+  const prevStatus = existing ? normalizeMissionStatus(existing.status) : null;
+  const prevGoal = existing?.goal ?? "";
   const record = {
     id,
     meshId,
@@ -7119,7 +7114,61 @@ function upsertMeshMission(meshId, input) {
   };
   store.upsertMission(record);
   const saved = store.getMission(meshId, id);
-  return { ...saved, status: normalizeMissionStatus(saved.status) };
+  const result = { ...saved, status: normalizeMissionStatus(saved.status) };
+  appendMissionLedgerEntries(meshId, {
+    isCreate: !existing,
+    record: result,
+    prevStatus,
+    prevGoal
+  });
+  return result;
+}
+function appendMissionLedgerEntries(meshId, args) {
+  const { isCreate, record, prevStatus, prevGoal } = args;
+  try {
+    if (isCreate) {
+      const goal = record.goal ?? "";
+      appendLedgerEntry(meshId, {
+        kind: "mission_created",
+        payload: {
+          missionId: record.id,
+          title: record.title,
+          goalSummary: summarizeGoalForLedger(goal),
+          goalLength: goal.length,
+          goalTruncated: goal.length > LEDGER_GOAL_SUMMARY_MAX,
+          status: record.status
+        }
+      });
+      return;
+    }
+    if (prevStatus !== null && prevStatus !== record.status) {
+      appendLedgerEntry(meshId, {
+        kind: "mission_status_changed",
+        payload: {
+          missionId: record.id,
+          title: record.title,
+          fromStatus: prevStatus,
+          toStatus: record.status
+        }
+      });
+    }
+    const nextGoal = record.goal ?? "";
+    if (nextGoal !== prevGoal) {
+      appendLedgerEntry(meshId, {
+        kind: "mission_goal_updated",
+        payload: {
+          missionId: record.id,
+          title: record.title,
+          prevGoalSummary: summarizeGoalForLedger(prevGoal),
+          nextGoalSummary: summarizeGoalForLedger(nextGoal),
+          prevGoalLength: prevGoal.length,
+          nextGoalLength: nextGoal.length,
+          goalTruncated: prevGoal.length > LEDGER_GOAL_SUMMARY_MAX || nextGoal.length > LEDGER_GOAL_SUMMARY_MAX
+        }
+      });
+    }
+  } catch {
+  }
 }
 function getMeshMissions(meshId, statuses) {
   return MeshRuntimeStore.getInstance().getMissions(meshId, statuses).map((m) => ({ ...m, status: normalizeMissionStatus(m.status) }));
@@ -7223,7 +7272,7 @@ function buildMissionPromptSection(meshId) {
   );
   return lines.join("\n");
 }
-var import_crypto7, MESH_MISSION_STATUSES, GOAL_PREVIEW_MAX, COMPACT_STATUS_GOAL_PREVIEW_MAX;
+var import_crypto7, LEDGER_GOAL_SUMMARY_MAX, MESH_MISSION_STATUSES, GOAL_PREVIEW_MAX, COMPACT_STATUS_GOAL_PREVIEW_MAX;
 var init_mesh_missions = __esm({
   "src/mesh/mesh-missions.ts"() {
     "use strict";
@@ -7231,6 +7280,8 @@ var init_mesh_missions = __esm({
     init_mesh_runtime_store();
     init_mesh_work_queue();
     init_mesh_task_stats();
+    init_mesh_ledger();
+    LEDGER_GOAL_SUMMARY_MAX = 200;
     MESH_MISSION_STATUSES = ["active", "paused", "completed", "abandoned"];
     GOAL_PREVIEW_MAX = 120;
     COMPACT_STATUS_GOAL_PREVIEW_MAX = 80;
@@ -8684,6 +8735,216 @@ var init_worktree_bootstrap_config = __esm({
   }
 });
 
+// src/config/mesh-json-config.ts
+var mesh_json_config_exports = {};
+__export(mesh_json_config_exports, {
+  MESH_JSON_CONFIG_LOCATIONS: () => MESH_JSON_CONFIG_LOCATIONS,
+  MESH_JSON_CONFIG_SCHEMA: () => MESH_JSON_CONFIG_SCHEMA,
+  applyRepoMeshConfig: () => applyRepoMeshConfig,
+  buildMeshJsonConfigScaffold: () => buildMeshJsonConfigScaffold,
+  loadRepoMeshJsonConfig: () => loadRepoMeshJsonConfig,
+  mergeEffectiveCoordinatorConfig: () => mergeEffectiveCoordinatorConfig,
+  mergeEffectiveOperatingNotes: () => mergeEffectiveOperatingNotes,
+  normalizeRepoMeshDeclarativeConfig: () => normalizeRepoMeshDeclarativeConfig,
+  serializeMeshJsonConfigScaffold: () => serializeMeshJsonConfigScaffold
+});
+function isRecord3(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function parseConfigText4(path43, text) {
+  if (/\.json$/i.test(path43)) return JSON.parse(text);
+  return yaml4.load(text);
+}
+function normalizeOperatingNote(value) {
+  if (!isRecord3(value)) return null;
+  const text = typeof value.text === "string" ? value.text.trim() : "";
+  if (!text) return null;
+  const category = value.category === "provider_quirk" || value.category === "pattern_to_avoid" || value.category === "recovery_lesson" ? value.category : void 0;
+  return {
+    text,
+    ...category ? { category } : {},
+    ...typeof value.createdAt === "string" ? { createdAt: value.createdAt } : {},
+    ...typeof value.sourceCoordinator === "string" ? { sourceCoordinator: value.sourceCoordinator } : {}
+  };
+}
+function normalizeRepoMeshDeclarativeConfig(parsed) {
+  const errors = [];
+  if (!isRecord3(parsed)) return { valid: false, errors: ["config must be an object"] };
+  if (parsed.version !== 1) {
+    return { valid: false, errors: [`version must be 1 (got ${JSON.stringify(parsed.version)})`] };
+  }
+  const config = { version: 1 };
+  if (parsed.coordinator !== void 0) {
+    if (isRecord3(parsed.coordinator)) {
+      const coord = {};
+      const c = parsed.coordinator;
+      if (typeof c.systemPromptOverride === "string") coord.systemPromptOverride = c.systemPromptOverride;
+      if (typeof c.systemPromptAppend === "string") coord.systemPromptAppend = c.systemPromptAppend;
+      if (Number.isFinite(Number(c.maxPromptChars))) coord.maxPromptChars = Number(c.maxPromptChars);
+      config.coordinator = coord;
+    } else {
+      errors.push("coordinator must be an object when provided");
+    }
+  }
+  if (parsed.operatingNotes !== void 0) {
+    if (Array.isArray(parsed.operatingNotes)) {
+      const notes = parsed.operatingNotes.map(normalizeOperatingNote).filter((n) => n !== null);
+      if (notes.length) config.operatingNotes = notes;
+    } else {
+      errors.push("operatingNotes must be an array when provided");
+    }
+  }
+  if (parsed.limits !== void 0) {
+    if (isRecord3(parsed.limits)) {
+      const limits = {};
+      if (Number.isFinite(Number(parsed.limits.maxNoteChars))) limits.maxNoteChars = Number(parsed.limits.maxNoteChars);
+      if (Number.isFinite(Number(parsed.limits.maxNotes))) limits.maxNotes = Number(parsed.limits.maxNotes);
+      if (Object.keys(limits).length) config.limits = limits;
+    } else {
+      errors.push("limits must be an object when provided");
+    }
+  }
+  return { valid: true, config, errors };
+}
+function loadRepoMeshJsonConfig(workspace) {
+  const bases = [];
+  const ws = typeof workspace === "string" ? workspace.trim() : "";
+  if (ws) bases.push(ws);
+  let cwd = "";
+  try {
+    cwd = process.cwd();
+  } catch {
+  }
+  if (cwd && cwd !== ws) bases.push(cwd);
+  for (const base of bases) {
+    for (const relative5 of MESH_JSON_CONFIG_LOCATIONS) {
+      const configPath = (0, import_path9.join)(base, relative5);
+      if (!(0, import_fs10.existsSync)(configPath)) continue;
+      try {
+        const parsed = parseConfigText4(configPath, (0, import_fs10.readFileSync)(configPath, "utf-8"));
+        const result = normalizeRepoMeshDeclarativeConfig(parsed);
+        if (!result.valid || !result.config) {
+          return { source: relative5, sourceType: "invalid", path: configPath, error: result.errors.join("; ") };
+        }
+        return { config: result.config, source: relative5, sourceType: "repo_file", path: configPath };
+      } catch (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_fs10, import_path9, yaml4, MESH_JSON_CONFIG_LOCATIONS, MESH_JSON_CONFIG_SCHEMA;
+var init_mesh_json_config = __esm({
+  "src/config/mesh-json-config.ts"() {
+    "use strict";
+    import_fs10 = require("fs");
+    import_path9 = 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() : "";
@@ -10151,9 +10412,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_path9.join)(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
+    return (0, import_path10.join)(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
   }
-  return (0, import_path9.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
+  return (0, import_path10.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
 }
 function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
   if (!meshId) return [];
@@ -10162,9 +10423,9 @@ function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
   const paths = primaryDaemonId ? [getPendingEventsPath(meshId, primaryDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   const events = [];
   for (const path43 of paths) {
-    if (!(0, import_fs10.existsSync)(path43)) continue;
+    if (!(0, import_fs11.existsSync)(path43)) continue;
     try {
-      const raw = (0, import_fs10.readFileSync)(path43, "utf-8");
+      const raw = (0, import_fs11.readFileSync)(path43, "utf-8");
       const parsed = raw.split("\n").filter(Boolean).flatMap((line) => {
         try {
           return [JSON.parse(line)];
@@ -10239,9 +10500,9 @@ function reconcilePendingMeshCoordinatorEvents(meshId, events) {
 }
 function trimPendingEventsIfNeeded(path43) {
   try {
-    if (!(0, import_fs10.existsSync)(path43)) return;
-    if ((0, import_fs10.statSync)(path43).size <= MAX_PENDING_EVENTS_BYTES) return;
-    const lines = (0, import_fs10.readFileSync)(path43, "utf-8").split("\n").filter(Boolean);
+    if (!(0, import_fs11.existsSync)(path43)) return;
+    if ((0, import_fs11.statSync)(path43).size <= MAX_PENDING_EVENTS_BYTES) return;
+    const lines = (0, import_fs11.readFileSync)(path43, "utf-8").split("\n").filter(Boolean);
     if (lines.length <= MAX_PENDING_EVENTS_KEEP) return;
     const dropped = lines.slice(0, lines.length - MAX_PENDING_EVENTS_KEEP);
     for (const line of dropped) {
@@ -10274,7 +10535,7 @@ function trimPendingEventsIfNeeded(path43) {
         LOG.warn("MeshEvents", `Failed to ledger-record trim-dropped ${event.event} for mesh ${event.meshId}: ${e?.message || e}`);
       }
     }
-    (0, import_fs10.writeFileSync)(path43, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
+    (0, import_fs11.writeFileSync)(path43, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
   } catch {
   }
 }
@@ -10306,7 +10567,7 @@ function queuePendingMeshCoordinatorEvent(event) {
     try {
       const path43 = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
       trimPendingEventsIfNeeded(path43);
-      (0, import_fs10.appendFileSync)(path43, JSON.stringify(event) + "\n", "utf-8");
+      (0, import_fs11.appendFileSync)(path43, JSON.stringify(event) + "\n", "utf-8");
     } catch (e) {
       if (!sqliteOk) throw e;
       LOG.warn("MeshEvents", `JSONL append failed for mesh ${event.meshId}; SQLite holds the event: ${e?.message || e}`);
@@ -10320,20 +10581,20 @@ function queuePendingMeshCoordinatorEvent(event) {
 function atomicDrainFile(path43) {
   const tmpPath = `${path43}.draining`;
   try {
-    (0, import_fs10.renameSync)(path43, tmpPath);
+    (0, import_fs11.renameSync)(path43, tmpPath);
   } catch {
     return null;
   }
   try {
-    const content = (0, import_fs10.readFileSync)(tmpPath, "utf-8");
+    const content = (0, import_fs11.readFileSync)(tmpPath, "utf-8");
     try {
-      (0, import_fs10.unlinkSync)(tmpPath);
+      (0, import_fs11.unlinkSync)(tmpPath);
     } catch {
     }
     return content;
   } catch {
     try {
-      (0, import_fs10.unlinkSync)(tmpPath);
+      (0, import_fs11.unlinkSync)(tmpPath);
     } catch {
     }
     return null;
@@ -10342,16 +10603,16 @@ function atomicDrainFile(path43) {
 function selectiveDrainFile(path43, predicate) {
   const tmpPath = `${path43}.draining`;
   try {
-    (0, import_fs10.renameSync)(path43, tmpPath);
+    (0, import_fs11.renameSync)(path43, tmpPath);
   } catch {
     return [];
   }
   let content;
   try {
-    content = (0, import_fs10.readFileSync)(tmpPath, "utf-8");
+    content = (0, import_fs11.readFileSync)(tmpPath, "utf-8");
   } catch {
     try {
-      (0, import_fs10.unlinkSync)(tmpPath);
+      (0, import_fs11.unlinkSync)(tmpPath);
     } catch {
     }
     return [];
@@ -10374,12 +10635,12 @@ function selectiveDrainFile(path43, predicate) {
   }
   try {
     if (keptLines.length > 0) {
-      (0, import_fs10.writeFileSync)(path43, keptLines.join("\n") + "\n", "utf-8");
+      (0, import_fs11.writeFileSync)(path43, keptLines.join("\n") + "\n", "utf-8");
     }
-    (0, import_fs10.unlinkSync)(tmpPath);
+    (0, import_fs11.unlinkSync)(tmpPath);
   } catch {
     try {
-      if ((0, import_fs10.existsSync)(tmpPath) && !(0, import_fs10.existsSync)(path43)) (0, import_fs10.renameSync)(tmpPath, path43);
+      if ((0, import_fs11.existsSync)(tmpPath) && !(0, import_fs11.existsSync)(path43)) (0, import_fs11.renameSync)(tmpPath, path43);
     } catch {
     }
     return [];
@@ -10474,18 +10735,18 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   }
   const paths = coordinatorDaemonId ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   for (const path43 of paths) {
-    if ((0, import_fs10.existsSync)(path43)) try {
-      (0, import_fs10.unlinkSync)(path43);
+    if ((0, import_fs11.existsSync)(path43)) try {
+      (0, import_fs11.unlinkSync)(path43);
     } catch {
     }
   }
 }
-var import_fs10, import_path9, import_crypto8, REFINE_TERMINAL_EVENTS, TERMINAL_COMPLETION_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
+var import_fs11, import_path10, import_crypto8, REFINE_TERMINAL_EVENTS, TERMINAL_COMPLETION_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP;
 var init_mesh_events_pending = __esm({
   "src/mesh/mesh-events-pending.ts"() {
     "use strict";
-    import_fs10 = require("fs");
-    import_path9 = require("path");
+    import_fs11 = require("fs");
+    import_path10 = require("path");
     import_crypto8 = require("crypto");
     init_logger();
     init_mesh_ledger();
@@ -11257,7 +11518,7 @@ function resolveCommandPath(command) {
   if (isExplicitCommandPath(trimmed)) {
     const expanded = expandHome(trimmed);
     const candidate = path12.isAbsolute(expanded) ? expanded : path12.resolve(expanded);
-    return (0, import_fs11.existsSync)(candidate) ? candidate : null;
+    return (0, import_fs12.existsSync)(candidate) ? candidate : null;
   }
   return null;
 }
@@ -11267,7 +11528,7 @@ async function resolveDetectionPath(command, whichCmd) {
   const whichResult = await execAsync(`${whichCmd} ${shellQuote(command)}`);
   if (whichResult) return whichResult.split("\n")[0];
   const resolved = findBinary(command);
-  if (path12.isAbsolute(resolved) && (0, import_fs11.existsSync)(resolved)) return resolved;
+  if (path12.isAbsolute(resolved) && (0, import_fs12.existsSync)(resolved)) return resolved;
   return null;
 }
 function execAsync(cmd, timeoutMs = 5e3) {
@@ -11362,14 +11623,14 @@ async function detectCLI(cliId, providerLoader, options) {
   const all = await detectCLIs(providerLoader, options);
   return all.find((c) => c.id === resolvedId && c.installed) || null;
 }
-var import_child_process2, os6, path12, import_fs11;
+var import_child_process2, os6, path12, import_fs12;
 var init_cli_detector = __esm({
   "src/detection/cli-detector.ts"() {
     "use strict";
     import_child_process2 = require("child_process");
     os6 = __toESM(require("os"));
     path12 = __toESM(require("path"));
-    import_fs11 = require("fs");
+    import_fs12 = require("fs");
     init_provider_cli_shared();
   }
 });
@@ -11490,345 +11751,6 @@ var init_mesh_warmup_deadline = __esm({
   }
 });
 
-// src/config/mesh-json-config.ts
-var mesh_json_config_exports = {};
-__export(mesh_json_config_exports, {
-  MESH_JSON_CONFIG_LOCATIONS: () => MESH_JSON_CONFIG_LOCATIONS,
-  MESH_JSON_CONFIG_SCHEMA: () => MESH_JSON_CONFIG_SCHEMA,
-  __resetMeshJsonConfigCacheForTests: () => __resetMeshJsonConfigCacheForTests,
-  applyRepoMeshConfig: () => applyRepoMeshConfig,
-  buildMeshJsonConfigScaffold: () => buildMeshJsonConfigScaffold,
-  diffPolicyFromDefault: () => diffPolicyFromDefault,
-  loadMeshJsonConfig: () => loadMeshJsonConfig,
-  loadRepoMeshJsonConfig: () => loadRepoMeshJsonConfig,
-  mergeEffectiveCoordinatorConfig: () => mergeEffectiveCoordinatorConfig,
-  mergeEffectiveMeshPolicy: () => mergeEffectiveMeshPolicy,
-  mergeEffectiveOperatingNotes: () => mergeEffectiveOperatingNotes,
-  normalizeRepoMeshDeclarativeConfig: () => normalizeRepoMeshDeclarativeConfig,
-  serializeMeshJsonConfigScaffold: () => serializeMeshJsonConfigScaffold,
-  validateMeshJsonConfig: () => validateMeshJsonConfig
-});
-function isRecord3(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function parseConfigText4(path43, text) {
-  if (/\.json$/i.test(path43)) return JSON.parse(text);
-  return yaml4.load(text);
-}
-function normalizeOperatingNote(value) {
-  if (!isRecord3(value)) return null;
-  const text = typeof value.text === "string" ? value.text.trim() : "";
-  if (!text) return null;
-  const category = value.category === "provider_quirk" || value.category === "pattern_to_avoid" || value.category === "recovery_lesson" ? value.category : void 0;
-  return {
-    text,
-    ...category ? { category } : {},
-    ...typeof value.createdAt === "string" ? { createdAt: value.createdAt } : {},
-    ...typeof value.sourceCoordinator === "string" ? { sourceCoordinator: value.sourceCoordinator } : {}
-  };
-}
-function normalizeRepoMeshDeclarativeConfig(parsed) {
-  const errors = [];
-  if (!isRecord3(parsed)) return { valid: false, errors: ["config must be an object"] };
-  if (parsed.version !== 1) {
-    return { valid: false, errors: [`version must be 1 (got ${JSON.stringify(parsed.version)})`] };
-  }
-  const config = { version: 1 };
-  if (parsed.policy !== void 0) {
-    if (isRecord3(parsed.policy)) {
-      config.policy = parsed.policy;
-    } else {
-      errors.push("policy must be an object when provided");
-    }
-  }
-  if (parsed.coordinator !== void 0) {
-    if (isRecord3(parsed.coordinator)) {
-      const coord = {};
-      const c = parsed.coordinator;
-      if (typeof c.systemPromptOverride === "string") coord.systemPromptOverride = c.systemPromptOverride;
-      if (typeof c.systemPromptAppend === "string") coord.systemPromptAppend = c.systemPromptAppend;
-      if (Number.isFinite(Number(c.maxPromptChars))) coord.maxPromptChars = Number(c.maxPromptChars);
-      config.coordinator = coord;
-    } else {
-      errors.push("coordinator must be an object when provided");
-    }
-  }
-  if (parsed.operatingNotes !== void 0) {
-    if (Array.isArray(parsed.operatingNotes)) {
-      const notes = parsed.operatingNotes.map(normalizeOperatingNote).filter((n) => n !== null);
-      if (notes.length) config.operatingNotes = notes;
-    } else {
-      errors.push("operatingNotes must be an array when provided");
-    }
-  }
-  if (parsed.limits !== void 0) {
-    if (isRecord3(parsed.limits)) {
-      const limits = {};
-      if (Number.isFinite(Number(parsed.limits.maxNoteChars))) limits.maxNoteChars = Number(parsed.limits.maxNoteChars);
-      if (Number.isFinite(Number(parsed.limits.maxNotes))) limits.maxNotes = Number(parsed.limits.maxNotes);
-      if (Object.keys(limits).length) config.limits = limits;
-    } else {
-      errors.push("limits must be an object when provided");
-    }
-  }
-  return { valid: true, config, errors };
-}
-function loadRepoMeshJsonConfig(workspace) {
-  const bases = [];
-  const ws = typeof workspace === "string" ? workspace.trim() : "";
-  if (ws) bases.push(ws);
-  let cwd = "";
-  try {
-    cwd = process.cwd();
-  } catch {
-  }
-  if (cwd && cwd !== ws) bases.push(cwd);
-  for (const base of bases) {
-    for (const relative5 of MESH_JSON_CONFIG_LOCATIONS) {
-      const configPath = (0, import_path10.join)(base, relative5);
-      if (!(0, import_fs12.existsSync)(configPath)) continue;
-      try {
-        const parsed = parseConfigText4(configPath, (0, import_fs12.readFileSync)(configPath, "utf-8"));
-        const result = normalizeRepoMeshDeclarativeConfig(parsed);
-        if (!result.valid || !result.config) {
-          return { source: relative5, sourceType: "invalid", path: configPath, error: result.errors.join("; ") };
-        }
-        return { config: result.config, source: relative5, sourceType: "repo_file", path: configPath };
-      } catch (error) {
-        return { source: relative5, sourceType: "invalid", path: configPath, error: error?.message || String(error) };
-      }
-    }
-  }
-  return {
-    source: "unavailable",
-    sourceType: "unavailable",
-    error: `No repo mesh config found. Checked: ${MESH_JSON_CONFIG_LOCATIONS.join(", ")}`
-  };
-}
-function deepEqual(a, b) {
-  if (a === b) return true;
-  try {
-    return JSON.stringify(a) === JSON.stringify(b);
-  } catch {
-    return false;
-  }
-}
-function diffPolicyFromDefault(local) {
-  if (!local || typeof local !== "object") return {};
-  const out = {};
-  const def = mergeAndNormalizePolicy(void 0, void 0);
-  for (const [key, value] of Object.entries(local)) {
-    if (value === void 0) continue;
-    if (!deepEqual(value, def[key])) out[key] = value;
-  }
-  return out;
-}
-function mergeEffectiveMeshPolicy(repoPolicy, localPolicy) {
-  const repoMerged = mergeAndNormalizePolicy(void 0, repoPolicy);
-  const localOverrides = diffPolicyFromDefault(localPolicy);
-  return mergeAndNormalizePolicy(repoMerged, localOverrides);
-}
-function mergeEffectiveCoordinatorConfig(repoCoord, localCoord) {
-  const out = { ...localCoord || {} };
-  const localOverride = localCoord?.systemPromptOverride?.trim();
-  const repoOverride = repoCoord?.systemPromptOverride?.trim();
-  if (localOverride) {
-    out.systemPromptOverride = localCoord.systemPromptOverride;
-  } else if (repoOverride) {
-    out.systemPromptOverride = repoCoord.systemPromptOverride;
-  } else {
-    delete out.systemPromptOverride;
-  }
-  const repoAppend = repoCoord?.systemPromptAppend?.trim() ? repoCoord.systemPromptAppend.trim() : "";
-  const localAppendRaw = localCoord?.systemPromptAppend ?? localCoord?.systemPromptSuffix;
-  const localAppend = localAppendRaw?.trim() ? localAppendRaw.trim() : "";
-  const stacked = [repoAppend, localAppend].filter(Boolean).join("\n\n");
-  if (stacked) {
-    out.systemPromptAppend = stacked;
-    delete out.systemPromptSuffix;
-  }
-  return out;
-}
-function mergeEffectiveOperatingNotes(repoNotes, ledgerNotes) {
-  const usable = (notes) => Array.isArray(notes) ? notes.filter((n) => n && typeof n.text === "string" && n.text.trim()) : [];
-  const repo = usable(repoNotes);
-  const ledger = usable(ledgerNotes);
-  const ledgerTexts = new Set(ledger.map((n) => n.text.trim()));
-  const repoKept = repo.filter((n) => !ledgerTexts.has(n.text.trim()));
-  const merged = [...repoKept, ...ledger];
-  return merged.length ? merged : void 0;
-}
-function applyRepoMeshConfig(mesh, repoConfig) {
-  if (!repoConfig) return mesh;
-  return {
-    ...mesh,
-    policy: mergeEffectiveMeshPolicy(repoConfig.policy, mesh.policy),
-    coordinator: mergeEffectiveCoordinatorConfig(repoConfig.coordinator, mesh.coordinator)
-  };
-}
-function buildMeshJsonConfigScaffold(mesh) {
-  const scaffold = {
-    version: 1,
-    policy: mergeAndNormalizePolicy(void 0, mesh.policy)
-  };
-  const coord = {};
-  const override = mesh.coordinator?.systemPromptOverride;
-  if (typeof override === "string" && override.trim()) coord.systemPromptOverride = override;
-  const append = mesh.coordinator?.systemPromptAppend ?? mesh.coordinator?.systemPromptSuffix;
-  if (typeof append === "string" && append.trim()) coord.systemPromptAppend = append;
-  if (Object.keys(coord).length) scaffold.coordinator = coord;
-  return scaffold;
-}
-function serializeMeshJsonConfigScaffold(config) {
-  return JSON.stringify(config, null, 2);
-}
-function validateMeshJsonConfig(raw, source = "inline") {
-  const errors = [];
-  if (!isRecord3(raw)) {
-    return { valid: false, errors: [`${source}: config must be an object`] };
-  }
-  const config = {};
-  const policy = raw.policy;
-  const schedulingRaw = isRecord3(policy) ? policy.scheduling : void 0;
-  if (schedulingRaw !== void 0) {
-    if (!isRecord3(schedulingRaw)) {
-      errors.push("policy.scheduling must be an object");
-    } else {
-      const scheduling = {};
-      if (schedulingRaw.distribution !== void 0) {
-        if (typeof schedulingRaw.distribution !== "string" || !["spread", "in_order"].includes(schedulingRaw.distribution.trim())) {
-          errors.push("policy.scheduling.distribution must be 'spread' or 'in_order'");
-        } else {
-          scheduling.distribution = normalizeMeshDistribution(schedulingRaw.distribution);
-        }
-      }
-      if (schedulingRaw.maxParallel !== void 0) {
-        const n = Number(schedulingRaw.maxParallel);
-        if (!Number.isFinite(n) || n < MESH_MAX_PARALLEL_TASKS_MIN || n > MESH_MAX_PARALLEL_TASKS_MAX) {
-          errors.push(`policy.scheduling.maxParallel must be a number in [${MESH_MAX_PARALLEL_TASKS_MIN}, ${MESH_MAX_PARALLEL_TASKS_MAX}]`);
-        } else {
-          scheduling.maxParallel = Math.floor(n);
-        }
-      }
-      if (schedulingRaw.readonlyMultiplier !== void 0) {
-        const n = Number(schedulingRaw.readonlyMultiplier);
-        if (!Number.isFinite(n) || n < 1) {
-          errors.push("policy.scheduling.readonlyMultiplier must be a number >= 1");
-        } else {
-          scheduling.readonlyMultiplier = Math.floor(n);
-        }
-      }
-      for (const key of Object.keys(schedulingRaw)) {
-        if (!["distribution", "maxParallel", "readonlyMultiplier"].includes(key)) {
-          errors.push(`policy.scheduling.${key} is not a recognized field`);
-        }
-      }
-      if (Object.keys(scheduling).length) config.scheduling = scheduling;
-    }
-  }
-  return { valid: errors.length === 0, errors, config: errors.length === 0 ? config : void 0 };
-}
-function loadMeshJsonConfig(repoRoot) {
-  if (!repoRoot) {
-    return { source: "unavailable", sourceType: "unavailable", error: "no repo root", sourceKey: "unavailable" };
-  }
-  for (const relative5 of MESH_JSON_CONFIG_LOCATIONS) {
-    const configPath = (0, import_path10.join)(repoRoot, relative5);
-    if (!(0, import_fs12.existsSync)(configPath)) continue;
-    let mtimeMs = 0;
-    try {
-      mtimeMs = (0, import_fs12.statSync)(configPath).mtimeMs;
-    } catch {
-      mtimeMs = 0;
-    }
-    const cacheKey = configPath;
-    const sourceKey = `file:${configPath}:${mtimeMs}`;
-    const cached3 = cache.get(cacheKey);
-    if (cached3 && cached3.sourceKey === sourceKey) return cached3.result;
-    let result;
-    try {
-      const text = (0, import_fs12.readFileSync)(configPath, "utf-8");
-      const parsed = parseConfigText4(configPath, text);
-      const validation = validateMeshJsonConfig(parsed, relative5);
-      result = validation.valid ? { config: validation.config, source: relative5, sourceType: "repo_file", path: configPath, sourceKey } : { source: relative5, sourceType: "invalid", path: configPath, error: validation.errors.join("; "), sourceKey: `invalid:${configPath}:${mtimeMs}` };
-    } catch (error) {
-      result = { source: relative5, sourceType: "invalid", path: configPath, error: error?.message || String(error), sourceKey: `error:${configPath}` };
-    }
-    cache.set(cacheKey, { sourceKey: result.sourceKey, result });
-    return result;
-  }
-  return {
-    source: "unavailable",
-    sourceType: "unavailable",
-    error: `No .adhdev/mesh config found. Checked: ${MESH_JSON_CONFIG_LOCATIONS.join(", ")}`,
-    sourceKey: "unavailable"
-  };
-}
-function __resetMeshJsonConfigCacheForTests() {
-  cache.clear();
-}
-var import_fs12, import_path10, yaml4, MESH_JSON_CONFIG_LOCATIONS, MESH_JSON_CONFIG_SCHEMA, cache;
-var init_mesh_json_config = __esm({
-  "src/config/mesh-json-config.ts"() {
-    "use strict";
-    import_fs12 = require("fs");
-    import_path10 = require("path");
-    yaml4 = __toESM(require("js-yaml"));
-    init_repo_mesh_types();
-    MESH_JSON_CONFIG_LOCATIONS = [
-      ".adhdev/mesh.json",
-      ".adhdev/mesh.yaml",
-      ".adhdev/mesh.yml"
-    ];
-    MESH_JSON_CONFIG_SCHEMA = {
-      $schema: "https://json-schema.org/draft/2020-12/schema",
-      title: "ADHDev Repo Mesh Declarative Config",
-      type: "object",
-      additionalProperties: false,
-      required: ["version"],
-      properties: {
-        version: { const: 1 },
-        // policy is validated/normalized through mergeAndNormalizePolicy at merge
-        // time; the schema here only asserts it is an object.
-        policy: { type: "object" },
-        coordinator: {
-          type: "object",
-          additionalProperties: false,
-          properties: {
-            systemPromptOverride: { type: "string" },
-            systemPromptAppend: { type: "string" },
-            maxPromptChars: { type: "number", minimum: 1 }
-          }
-        },
-        operatingNotes: {
-          type: "array",
-          maxItems: 200,
-          items: {
-            type: "object",
-            additionalProperties: false,
-            required: ["text"],
-            properties: {
-              text: { type: "string", minLength: 1 },
-              category: { enum: ["provider_quirk", "pattern_to_avoid", "recovery_lesson"] },
-              createdAt: { type: "string" },
-              sourceCoordinator: { type: "string" }
-            }
-          }
-        },
-        limits: {
-          type: "object",
-          additionalProperties: false,
-          properties: {
-            maxNoteChars: { type: "number", minimum: 1 },
-            maxNotes: { type: "number", minimum: 1 }
-          }
-        }
-      }
-    };
-    cache = /* @__PURE__ */ new Map();
-  }
-});
-
 // src/mesh/mesh-queue-assignment.ts
 function __resetIdleAutoFastForwardForTests() {
   idleAutoFastForwardLastAttempt.clear();
@@ -12244,26 +12166,7 @@ function nodeHasActiveAssignment(meshId, nodeId) {
 function nodeActiveLoad(meshId, nodeId) {
   return MeshRuntimeStore.getInstance().nodeActiveAssignmentCount(meshId, nodeId);
 }
-function resolveMeshRepoRootForScheduling(mesh) {
-  const nodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
-  const pickRoot = (n) => readNonEmptyString2(n?.repoRoot) || readNonEmptyString2(n?.workspace);
-  const base = nodes.find((n) => n?.isLocalWorktree !== true && pickRoot(n));
-  if (base) return pickRoot(base);
-  const anyNode = nodes.find((n) => pickRoot(n));
-  return anyNode ? pickRoot(anyNode) : "";
-}
-function resolveMeshSchedulingOverride(mesh) {
-  const repoRoot = resolveMeshRepoRootForScheduling(mesh);
-  if (!repoRoot) return void 0;
-  try {
-    return loadMeshJsonConfig(repoRoot).config?.scheduling;
-  } catch {
-    return void 0;
-  }
-}
 function resolveSchedulingStrategy(mesh) {
-  const override = resolveMeshSchedulingOverride(mesh);
-  if (override?.distribution) return distributionToStrategy(override.distribution);
   return normalizeMeshSchedulingStrategy(mesh?.policy?.schedulingStrategy);
 }
 function orderEligibleNodes(meshId, strategy, nodes, opts) {
@@ -12406,11 +12309,8 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
   const queue = getQueue(meshId);
   const pending = queue.filter((task) => task.status === "pending");
   if (!pending.length) return false;
-  const schedulingOverride = resolveMeshSchedulingOverride(mesh);
-  const maxParallelTasks = resolveMaxParallelTasks(
-    schedulingOverride?.maxParallel ?? mesh?.policy?.maxParallelTasks
-  );
-  const maxReadonlyParallelTasks = resolveMaxReadonlyParallelTasks(maxParallelTasks, schedulingOverride?.readonlyMultiplier);
+  const maxParallelTasks = resolveMaxParallelTasks(mesh?.policy?.maxParallelTasks);
+  const maxReadonlyParallelTasks = resolveMaxReadonlyParallelTasks(maxParallelTasks);
   for (const task of pending) {
     const isReadonly = isTaskReadonly(task);
     if (isReadonly) {
@@ -12824,7 +12724,6 @@ var init_mesh_queue_assignment = __esm({
     init_mesh_event_trace();
     init_mesh_warmup_deadline();
     init_repo_mesh_types();
-    init_mesh_json_config();
     init_dist();
     init_mesh_events_stale();
     init_mesh_events_utils();
@@ -15039,11 +14938,11 @@ function buildRecentReadDebugSignature(snapshot) {
     String(snapshot.messageUpdatedAt)
   ].join("|");
 }
-function shouldEmitRecentReadDebugLog(cache2, snapshot) {
+function shouldEmitRecentReadDebugLog(cache, snapshot) {
   const nextSignature = buildRecentReadDebugSignature(snapshot);
-  const previousSignature = cache2.get(snapshot.sessionId);
+  const previousSignature = cache.get(snapshot.sessionId);
   if (previousSignature === nextSignature) return false;
-  cache2.set(snapshot.sessionId, nextSignature);
+  cache.set(snapshot.sessionId, nextSignature);
   return true;
 }
 function buildDetectedIdeInfos(detectedIdes, cdpManagers) {
@@ -23258,6 +23157,7 @@ __export(index_exports, {
   loadMeshCoordinatorRegistry: () => loadMeshCoordinatorRegistry,
   loadMeshRefineConfig: () => loadMeshRefineConfig,
   loadMeshWorktreeBootstrapConfig: () => loadMeshWorktreeBootstrapConfig,
+  loadRepoSettings: () => loadRepoSettings,
   loadState: () => loadState,
   logCommand: () => logCommand,
   machineCoreFromDaemonId: () => machineCoreFromDaemonId,
@@ -24634,6 +24534,29 @@ init_mesh_review_inbox();
 init_coordinator_registry();
 init_refine_config();
 init_worktree_bootstrap_config();
+
+// src/config/repo-settings.ts
+init_mesh_json_config();
+init_refine_config();
+init_worktree_bootstrap_config();
+init_change_impact_config();
+function loadRepoSettings(opts) {
+  const workspace = typeof opts.workspace === "string" ? opts.workspace : "";
+  const mesh = opts.mesh;
+  const repoRoot = typeof opts.repoRoot === "string" && opts.repoRoot ? opts.repoRoot : workspace;
+  const meshJson = loadRepoMeshJsonConfig(workspace);
+  return {
+    coordinator: meshJson.config?.coordinator,
+    operatingNotes: meshJson.config?.operatingNotes,
+    limits: meshJson.config?.limits,
+    meshJson,
+    refine: loadMeshRefineConfig(mesh, workspace),
+    worktreeBootstrap: loadMeshWorktreeBootstrapConfig(mesh, workspace),
+    changeImpact: loadChangeImpactConfig(repoRoot)
+  };
+}
+
+// src/index.ts
 init_mesh_ledger();
 init_mesh_fast_forward();
 
@@ -48660,6 +48583,21 @@ init_mesh_host_ownership();
 init_worktree_bootstrap_config();
 init_mesh_events();
 init_config();
+async function decideOssCloneSync(ossCtx, worktreeOssSha, sourceSha, rg) {
+  if (!worktreeOssSha || !sourceSha || worktreeOssSha === sourceSha) return "noop";
+  const isAncestor = async (ancestor, descendant) => {
+    try {
+      await rg(ossCtx, ["merge-base", "--is-ancestor", ancestor, descendant], { timeoutMs: 1e4 });
+      return true;
+    } catch (err) {
+      if (err?.exitCode === 1 || err?.code === 1) return false;
+      throw err;
+    }
+  };
+  if (await isAncestor(sourceSha, worktreeOssSha)) return "skip_rewind";
+  if (await isAncestor(worktreeOssSha, sourceSha)) return "advance";
+  return "skip_diverged";
+}
 var meshCrudHandlers = {
   list_meshes: async (_ctx, _args) => {
     try {
@@ -48750,7 +48688,8 @@ var meshCrudHandlers = {
   // entry. This is an export scaffold for the operator to review and commit to
   // the repo, NOT an automatic data migration: nothing is written to disk and
   // meshes.json is untouched. The returned `scaffold` (object) + `scaffoldJson`
-  // (2-space text) capture the local policy + coordinator prompt override/append.
+  // (2-space text) capture the coordinator prompt override/append (policy is
+  // machine-local and is intentionally NOT exported into mesh.json).
   export_mesh_json_config: async (_ctx, args) => {
     const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
     if (!meshId) return { success: false, error: "meshId required" };
@@ -49121,7 +49060,7 @@ var meshCrudHandlers = {
         }
       };
       const initSubmodules = sourceNode.policy?.initSubmodulesOnClone !== false;
-      const loadedBootstrap = loadMeshWorktreeBootstrapConfig(mesh, result.worktreePath);
+      const loadedBootstrap = loadRepoSettings({ workspace: result.worktreePath, mesh }).worktreeBootstrap;
       const runningBootstrapState = {
         status: "running",
         required: loadedBootstrap.config?.required !== false,
@@ -49155,12 +49094,25 @@ var meshCrudHandlers = {
                   const ossCtx = { workspace: `${result.worktreePath}/oss`, repoRoot: `${result.worktreePath}/oss`, isGitRepo: true };
                   const worktreeOssHeadOut = await rg(ossCtx, ["rev-parse", "HEAD"], { timeoutMs: 1e4 });
                   const worktreeOssSha = (typeof worktreeOssHeadOut === "string" ? worktreeOssHeadOut : worktreeOssHeadOut?.stdout ?? "").trim();
-                  if (worktreeOssSha !== sourceSha) {
+                  if (worktreeOssSha && worktreeOssSha !== sourceSha) {
                     await rg(ossCtx, ["fetch", `${sourceWorkspace}/oss`, "HEAD"], { timeoutMs: 6e4 });
-                    await rg(ossCtx, ["checkout", sourceSha], { timeoutMs: 1e4 });
-                    await rg(worktreeCtx, ["add", "oss"], { timeoutMs: 1e4 });
-                    await rg(worktreeCtx, ["commit", "-m", "chore: sync oss to source node HEAD on clone"], { timeoutMs: 1e4 });
-                    console.log(`[mesh] Synced oss submodule to source HEAD ${sourceSha.slice(0, 8)} in worktree`);
+                    let ossAction;
+                    try {
+                      ossAction = await decideOssCloneSync(ossCtx, worktreeOssSha, sourceSha, rg);
+                    } catch (decideErr) {
+                      ossAction = "skip_diverged";
+                      console.warn(`[mesh] oss submodule sync guard could not resolve ancestry (kept fresh worktree HEAD): ${decideErr?.message ?? decideErr}`);
+                    }
+                    if (ossAction === "advance") {
+                      await rg(ossCtx, ["checkout", sourceSha], { timeoutMs: 1e4 });
+                      await rg(worktreeCtx, ["add", "oss"], { timeoutMs: 1e4 });
+                      await rg(worktreeCtx, ["commit", "-m", "chore: sync oss to source node HEAD on clone"], { timeoutMs: 1e4 });
+                      console.log(`[mesh] Advanced oss submodule to newer source HEAD ${sourceSha.slice(0, 8)} in worktree`);
+                    } else if (ossAction === "skip_rewind") {
+                      console.warn(`[mesh] Skipped oss submodule rewind on clone: source node oss ${sourceSha.slice(0, 8)} is an ancestor of the fresh worktree oss ${worktreeOssSha.slice(0, 8)} \u2014 kept fresher worktree HEAD`);
+                    } else if (ossAction === "skip_diverged") {
+                      console.warn(`[mesh] Skipped oss submodule sync on clone: source node oss ${sourceSha.slice(0, 8)} diverged from the fresh worktree oss ${worktreeOssSha.slice(0, 8)} \u2014 kept worktree HEAD (coordinator reconciles)`);
+                    }
                   }
                 }
               } catch (ossErr) {
@@ -64643,6 +64595,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   loadMeshCoordinatorRegistry,
   loadMeshRefineConfig,
   loadMeshWorktreeBootstrapConfig,
+  loadRepoSettings,
   loadState,
   logCommand,
   machineCoreFromDaemonId,