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

package/dist/mesh/mesh-ledger.d.ts

@@ -14,7 +14,7 @@
  */
 import { EventEmitter } from 'events';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held' | 'task_reclaimed' | 'coordinator_operating_note';
+export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held' | 'task_reclaimed' | 'coordinator_operating_note' | 'mission_created' | 'mission_status_changed' | 'mission_goal_updated';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.411",
+  "version": "0.9.82-rc.412",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.411",
+    "@adhdev/mesh-shared": "0.9.82-rc.412",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/high-family/mesh-coordinator-launch.ts

@@ -177,10 +177,15 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
 
                     // OPSRULES — layer the repo-shared declarative mesh config
                     // (.adhdev/mesh.json in the coordinator node workspace, else
-                    // the calling cwd) UNDER the machine-local mesh entry. The
-                    // merge is LOCAL-WINS and in-memory only: meshes.json on disk
-                    // is never mutated. The effective mesh feeds prompt building;
-                    // operating notes are merged with the runtime ledger below.
+                    // the calling cwd) UNDER the machine-local mesh entry. Only the
+                    // COORDINATOR zone (prompt override/append) is merged — policy is
+                    // machine-local and is never sourced from the repo file. The merge
+                    // is in-memory only: meshes.json on disk is never mutated. Coordinator
+                    // launch needs only the mesh.json zone (coordinator + operatingNotes),
+                    // so it reads that dedicated loader directly rather than the unified
+                    // loadRepoSettings (which would also touch refine/bootstrap via the
+                    // machine-local inline seam). The effective mesh feeds prompt
+                    // building; operating notes are merged with the runtime ledger below.
                     const { loadRepoMeshJsonConfig, applyRepoMeshConfig, mergeEffectiveOperatingNotes } =
                         await import('../../config/mesh-json-config.js');
                     const repoMeshConfigLoad = loadRepoMeshJsonConfig(workspace);

package/src/commands/med-family/mesh-crud.ts

@@ -16,6 +16,7 @@ import {
     runMeshWorktreeBootstrap,
     type WorktreeBootstrapState,
 } from '../../mesh/worktree-bootstrap-config.js';
+import { loadRepoSettings } from '../../config/repo-settings.js';
 import { handleMeshForwardEvent, queuePendingMeshCoordinatorEvent } from '../../mesh/mesh-events.js';
 import { loadConfig } from '../../config/config.js';
 import {
@@ -24,8 +25,61 @@ import {
     readMeshNodeMachineId,
 } from '../router.js';
 import type { CommandRouterResult } from '../router.js';
+import type { GitRepoIdentity } from '../../git/git-types.js';
 import type { MedFamilyContext, MedFamilyHandler } from './types.js';
 
+/**
+ * Decision for syncing a freshly-cloned worktree's `oss` submodule to its clone
+ * source node, applying resolveWorktreeBaseStartPoint's origin-tip-priority
+ * policy to the submodule.
+ *
+ * On clone, `submodule update --init` checks the worktree's `oss` out at the
+ * gitlink recorded in the FRESH root base — which the root base-stale fix
+ * branches from origin/main, so it is the up-to-date origin tip. The clone
+ * source node's *working* `oss` SHA can lag that tip. The original sync blindly
+ * checked out the source SHA whenever it merely differed, which REWINDS the
+ * submodule back onto the stale source and re-introduces staleness.
+ *
+ * Guard policy (never rewind, mirror the base-start-point resolver):
+ *   - source SHA == worktree SHA            → `noop`
+ *   - source SHA is an ancestor of worktree → `skip_rewind`  (source is behind; keep fresh tip)
+ *   - worktree SHA is an ancestor of source → `advance`      (source strictly newer; safe fast-forward)
+ *   - neither is an ancestor (diverged)     → `skip_diverged` (keep fresh tip; coordinator reconciles)
+ *
+ * Both SHAs must already be resolvable in `ossCtx` (the caller fetches the
+ * source SHA first). A non-1 git exit (unresolvable SHA / real failure) is
+ * rethrown so the caller can fall back to keeping the fresh worktree HEAD.
+ */
+export type OssCloneSyncAction = 'noop' | 'advance' | 'skip_rewind' | 'skip_diverged';
+
+export async function decideOssCloneSync(
+    ossCtx: GitRepoIdentity,
+    worktreeOssSha: string,
+    sourceSha: string,
+    rg: (ctx: GitRepoIdentity, argv: string[], opts?: { timeoutMs?: number }) => Promise<unknown>,
+): Promise<OssCloneSyncAction> {
+    if (!worktreeOssSha || !sourceSha || worktreeOssSha === sourceSha) return 'noop';
+
+    const isAncestor = async (ancestor: string, descendant: string): Promise<boolean> => {
+        try {
+            await rg(ossCtx, ['merge-base', '--is-ancestor', ancestor, descendant], { timeoutMs: 10000 });
+            return true;
+        } catch (err: any) {
+            // `merge-base --is-ancestor` exits 1 for a clean "not an ancestor".
+            // Any other exit (128 = unresolvable commit, etc.) is a real failure.
+            if (err?.exitCode === 1 || err?.code === 1) return false;
+            throw err;
+        }
+    };
+
+    // Source is an ancestor of the fresh worktree tip → checking it out rewinds.
+    if (await isAncestor(sourceSha, worktreeOssSha)) return 'skip_rewind';
+    // Worktree tip is an ancestor of source → source is strictly newer → safe FF.
+    if (await isAncestor(worktreeOssSha, sourceSha)) return 'advance';
+    // Neither is an ancestor → diverged → keep the fresh worktree HEAD.
+    return 'skip_diverged';
+}
+
 export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
     list_meshes: async (_ctx: MedFamilyContext, _args: any) => {
         try {
@@ -129,7 +183,8 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
     // 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: MedFamilyContext, args: any) => {
         const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
         if (!meshId) return { success: false, error: 'meshId required' };
@@ -637,7 +692,10 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
             };
 
             const initSubmodules = (sourceNode.policy as any)?.initSubmodulesOnClone !== false;
-            const loadedBootstrap = loadMeshWorktreeBootstrapConfig(mesh, result.worktreePath);
+            // Read the worktree bootstrap config through the unified RepoSettings
+            // loader (file-separated `.adhdev/worktree_bootstrap.json`; machine-local
+            // inline seam honored). runMeshWorktreeBootstrap below re-loads it to run.
+            const loadedBootstrap = loadRepoSettings({ workspace: result.worktreePath, mesh }).worktreeBootstrap;
             const runningBootstrapState: WorktreeBootstrapState = {
                 status: 'running',
                 required: loadedBootstrap.config?.required !== false,
@@ -679,13 +737,32 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
                                     const worktreeOssHeadOut = await rg(ossCtx, ['rev-parse', 'HEAD'], { timeoutMs: 10000 });
                                     const worktreeOssSha = (typeof worktreeOssHeadOut === 'string' ? worktreeOssHeadOut : (worktreeOssHeadOut as any)?.stdout ?? '').trim();
 
-                                    if (worktreeOssSha !== sourceSha) {
-                                        // Fetch target SHA from source node's oss directory
+                                    if (worktreeOssSha && worktreeOssSha !== sourceSha) {
+                                        // Bring the source node's oss HEAD into the worktree object DB so
+                                        // both SHAs are resolvable for the ancestry (rewind) guard below.
                                         await rg(ossCtx, ['fetch', `${sourceWorkspace}/oss`, 'HEAD'], { timeoutMs: 60000 });
-                                        await rg(ossCtx, ['checkout', sourceSha], { timeoutMs: 10000 });
-                                        await rg(worktreeCtx, ['add', 'oss'], { timeoutMs: 10000 });
-                                        await rg(worktreeCtx, ['commit', '-m', 'chore: sync oss to source node HEAD on clone'], { timeoutMs: 10000 });
-                                        console.log(`[mesh] Synced oss submodule to source HEAD ${sourceSha.slice(0, 8)} in worktree`);
+
+                                        // Rewind guard: the worktree oss HEAD was just checked out from the
+                                        // FRESH (origin/main-derived) root base. Only advance to the source
+                                        // SHA when it is strictly newer — never rewind to a stale source.
+                                        let ossAction: OssCloneSyncAction;
+                                        try {
+                                            ossAction = await decideOssCloneSync(ossCtx, worktreeOssSha, sourceSha, rg);
+                                        } catch (decideErr: any) {
+                                            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: 10000 });
+                                            await rg(worktreeCtx, ['add', 'oss'], { timeoutMs: 10000 });
+                                            await rg(worktreeCtx, ['commit', '-m', 'chore: sync oss to source node HEAD on clone'], { timeoutMs: 10000 });
+                                            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)} — 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)} — kept worktree HEAD (coordinator reconciles)`);
+                                        }
                                     }
                                 }
                             } catch (ossErr: any) {

package/src/config/mesh-json-config.ts

@@ -1,77 +1,42 @@
 /**
  * Repo-shared declarative mesh config — `.adhdev/mesh.json`
  *
- * A repo-committed, machine-independent BASE for mesh declarative settings
- * (policy + coordinator prompt override/append + operating notes). It is the
- * lowest layer of a LOCAL-WINS merge chain:
+ * A repo-committed, machine-independent file carrying ONLY the repo-shared
+ * coordinator-prompt config and operating notes:
  *
- *   DEFAULT_MESH_POLICY  →  .adhdev/mesh.json (repo base)  →  machine-local
- *   meshes.json / coordinator-prompt files (always win)
- *
- * The merge is **in-memory only**. The on-disk machine-local `meshes.json` is
- * NEVER mutated by this module — local config keeps winning and the merge is
- * applied transiently on the coordinator launch + display paths. This keeps the
- * repo file a shared default that a machine can always override without the
- * override being silently rewritten back to the repo shape.
- *
- * Three zones (scope = mesh-global in v1; per-node scope is not introduced):
- *   - policy            — RepoMeshPolicy fields; local fields that differ from
- *                         DEFAULT_MESH_POLICY win, otherwise the repo base shows
- *                         through (true per-field LOCAL-WINS).
  *   - coordinator       — systemPromptOverride (local wins, else repo) and
  *                         systemPromptAppend (repo append + local append BOTH
  *                         stack, repo first).
  *   - operatingNotes    — repo-declared baseline notes merged with the runtime
  *                         ledger notes; on duplicate text the ledger note wins.
+ *   - limits            — advisory-only (`maxNoteChars`, `maxNotes`,
+ *                         `coordinator.maxPromptChars`); recorded, never enforced in v1.
  *
- * Advisory-only fields (`coordinator.maxPromptChars`, `limits.maxNoteChars`,
- * `limits.maxNotes`) are accepted and preserved in the schema but NOT enforced
- * in v1 — they document operator intent only.
- *
- * SCHEDULING OVERLAY — this same `.adhdev/mesh.json` also carries the in-tree
- * scheduling product surface (`policy.scheduling`). Instead of the scattered
- * `schedulingStrategy` / `maxParallelTasks` knobs (each with its own default +
- * clamp), an operator declares one `policy.scheduling` block checked into the
- * repo. It layers ON TOP of the stored meshes.json policy with LOCAL-WINS — a
- * value present in the repo file overrides the persisted mesh policy, so the
- * repo is the source of truth for how its own work distributes. Absent keys
- * leave the stored policy untouched (a partial overlay, not a replacement).
+ * POLICY IS NOT HERE. RepoMeshPolicy (the 15 scheduling/approval fields) is
+ * MACHINE-LOCAL only — it lives in meshes.json and is never sourced from, merged
+ * with, or overlaid by a repo file. There is no `policy` zone and no
+ * `policy.scheduling` overlay in mesh.json; the scheduler reads the stored
+ * machine-local policy directly. The repo file shapes the coordinator prompt and
+ * operating notes, nothing else.
  *
- *   .adhdev/mesh.json
- *   { "policy": { "scheduling": {
- *       "distribution": "spread" | "in_order",   // → schedulingStrategy
- *       "maxParallel": 1..8,                       // → maxParallelTasks (clamped)
- *       "readonlyMultiplier": 2                    // read-only cap multiplier (default 2)
- *   } } }
+ * The coordinator/operatingNotes merge is **in-memory only**: the on-disk
+ * machine-local `meshes.json` is never mutated by this module.
  *
- * The raw 4-union schedulingStrategy escape hatch is preserved elsewhere: a
- * hand-edited meshes.json may still write any of the four raw strategies and the
- * scheduler honors it. The scheduling overlay exposes only the 2-mode
- * `distribution` façade, mapped through distributionToStrategy.
- *
- * The declarative-config loader (`loadRepoMeshJsonConfig`) and the scheduling
- * overlay loader (`loadMeshJsonConfig`) read the SAME file but resolve different
- * zones; they coexist intentionally — coordinator launch/display consume the
- * declarative zones, the scheduler consumes the scheduling overlay.
+ * FILE SEPARATION: refine / worktree-bootstrap / change-impact configs live in
+ * their OWN `.adhdev/*` files with their own loaders — they are NOT inlined into
+ * mesh.json. `loadRepoSettings` (config/repo-settings.ts) assembles all of them
+ * into one object for consumers.
  *
  * SECURITY: declarative only. JSON/YAML is parsed; arbitrary JS (.js) is NOT
  * supported, so loading a config can never execute code.
  */
 
-import { existsSync, readFileSync, statSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 import * as yaml from 'js-yaml';
-import {
-    mergeAndNormalizePolicy,
-    type RepoMeshPolicy,
-    type RepoMeshCoordinatorConfig,
-    type LocalMeshEntry,
-    type RepoMeshDistribution,
-    distributionToStrategy,
-    normalizeMeshDistribution,
-    resolveMaxParallelTasks,
-    MESH_MAX_PARALLEL_TASKS_MIN,
-    MESH_MAX_PARALLEL_TASKS_MAX,
+import type {
+    RepoMeshCoordinatorConfig,
+    LocalMeshEntry,
 } from '../repo-mesh-types.js';
 import type { CoordinatorOperatingNote } from '../mesh/coordinator-prompt.js';
 
@@ -97,11 +62,11 @@ export interface RepoMeshDeclarativeLimits {
 
 /**
  * Parsed + normalized `.adhdev/mesh.json` shape. Every field is optional except
- * version so a repo can declare only the zone(s) it cares about.
+ * version so a repo can declare only the zone(s) it cares about. Policy is NOT a
+ * zone here — it is machine-local (meshes.json) only.
  */
 export interface RepoMeshDeclarativeConfig {
     version: 1;
-    policy?: Partial<RepoMeshPolicy>;
     coordinator?: RepoMeshDeclarativeCoordinatorConfig;
     operatingNotes?: CoordinatorOperatingNote[];
     limits?: RepoMeshDeclarativeLimits;
@@ -117,31 +82,10 @@ export interface RepoMeshJsonConfigLoadResult {
     error?: string;
 }
 
-// ─── Types (scheduling overlay) ─────────────────
-
-export interface MeshJsonSchedulingConfig {
-    /** User-facing distribution mode; mapped to schedulingStrategy on apply. */
-    distribution?: RepoMeshDistribution;
-    /** Global write-task parallel cap (clamped to [1, 8] on apply). */
-    maxParallel?: number;
-    /** Read-only diagnosis cap multiplier. Missing → 2. */
-    readonlyMultiplier?: number;
-}
-
-export interface MeshJsonConfig {
-    scheduling?: MeshJsonSchedulingConfig;
-}
-
-export interface MeshJsonConfigLoadResult {
-    config?: MeshJsonConfig;
-    source: string;
-    sourceType: 'repo_file' | 'unavailable' | 'invalid';
-    path?: string;
-    error?: string;
-    /** Cache key: path + mtime, or a sentinel for the missing/invalid case. */
-    sourceKey: string;
-}
-
+// MESH_JSON_CONFIG_LOCATIONS is retained for backward compatibility: it is the
+// shared list of `.adhdev/mesh.*` filenames the loader probes (and other modules
+// reference for diagnostics). The file now carries only coordinator + operating
+// notes; there is no scheduling overlay.
 export const MESH_JSON_CONFIG_LOCATIONS = [
     '.adhdev/mesh.json',
     '.adhdev/mesh.yaml',
@@ -156,9 +100,6 @@ export const MESH_JSON_CONFIG_SCHEMA = {
     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,
@@ -242,14 +183,6 @@ export function normalizeRepoMeshDeclarativeConfig(parsed: unknown): {
 
     const config: RepoMeshDeclarativeConfig = { version: 1 };
 
-    if (parsed.policy !== undefined) {
-        if (isRecord(parsed.policy)) {
-            config.policy = parsed.policy as Partial<RepoMeshPolicy>;
-        } else {
-            errors.push('policy must be an object when provided');
-        }
-    }
-
     if (parsed.coordinator !== undefined) {
         if (isRecord(parsed.coordinator)) {
             const coord: RepoMeshDeclarativeCoordinatorConfig = {};
@@ -334,51 +267,7 @@ export function loadRepoMeshJsonConfig(workspace?: string): RepoMeshJsonConfigLo
     };
 }
 
-// ─── Declarative config: Merge (LOCAL-WINS) ─────
-
-function deepEqual(a: unknown, b: unknown): boolean {
-    if (a === b) return true;
-    try { return JSON.stringify(a) === JSON.stringify(b); } catch { return false; }
-}
-
-/**
- * Reduce a (fully-normalized) machine-local policy to ONLY the fields that
- * genuinely differ from DEFAULT_MESH_POLICY. A meshes.json policy is always
- * stored fully-defaulted, so a naive merge would let it shadow every repo-base
- * field — defeating the repo default. By keeping only the truly-overridden
- * fields, an untouched local field falls through to the repo base while a local
- * field the operator actually changed still wins. Optional fields absent from
- * DEFAULT_MESH_POLICY (e.g. allowedProviders, schedulingStrategy) count as an
- * override whenever present.
- */
-export function diffPolicyFromDefault(local: Partial<RepoMeshPolicy> | undefined): Partial<RepoMeshPolicy> {
-    if (!local || typeof local !== 'object') return {};
-    const out: Record<string, unknown> = {};
-    // Compare against the NORMALIZED default (not the raw DEFAULT_MESH_POLICY) so a
-    // fully-normalized local policy — whose nested autoFastForward is filled out by
-    // normalizeAutoFastForwardPolicy — does not spuriously read as an override.
-    const def = mergeAndNormalizePolicy(undefined, undefined) as unknown as Record<string, unknown>;
-    for (const [key, value] of Object.entries(local)) {
-        if (value === undefined) continue;
-        if (!deepEqual(value, def[key])) out[key] = value;
-    }
-    return out as Partial<RepoMeshPolicy>;
-}
-
-/**
- * Effective mesh policy = DEFAULT → repo base → local overrides (per-field
- * LOCAL-WINS). When `local` is all-default the repo base shows through entirely
- * (case i); when `local` overrides a field that field wins (case ii). Nested
- * objects (autoFastForward) are still merged per-field by mergeAndNormalizePolicy.
- */
-export function mergeEffectiveMeshPolicy(
-    repoPolicy: Partial<RepoMeshPolicy> | undefined,
-    localPolicy: RepoMeshPolicy | Partial<RepoMeshPolicy> | undefined,
-): RepoMeshPolicy {
-    const repoMerged = mergeAndNormalizePolicy(undefined, repoPolicy);
-    const localOverrides = diffPolicyFromDefault(localPolicy);
-    return mergeAndNormalizePolicy(repoMerged, localOverrides);
-}
+// ─── Declarative config: Merge (coordinator + operating notes) ─────
 
 /**
  * Effective coordinator config. systemPromptOverride: local wins, else repo.
@@ -440,18 +329,19 @@ export function mergeEffectiveOperatingNotes(
 
 /**
  * Produce an in-memory effective mesh by layering the repo declarative config
- * UNDER the machine-local mesh entry (policy + coordinator zones). Returns a new
- * object; the input mesh and on-disk meshes.json are never mutated. operatingNotes
- * are merged separately at launch (they ride the prompt context, not the mesh).
+ * UNDER the machine-local mesh entry — coordinator zone ONLY. Policy is
+ * machine-local and is left exactly as the stored mesh carries it (never sourced
+ * from the repo file). Returns a new object; the input mesh and on-disk
+ * meshes.json are never mutated. operatingNotes are merged separately at launch
+ * (they ride the prompt context, not the mesh).
  */
-export function applyRepoMeshConfig<T extends Pick<LocalMeshEntry, 'policy' | 'coordinator'>>(
+export function applyRepoMeshConfig<T extends Pick<LocalMeshEntry, 'coordinator'>>(
     mesh: T,
     repoConfig: RepoMeshDeclarativeConfig | null | undefined,
 ): T {
     if (!repoConfig) return mesh;
     return {
         ...mesh,
-        policy: mergeEffectiveMeshPolicy(repoConfig.policy, mesh.policy),
         coordinator: mergeEffectiveCoordinatorConfig(repoConfig.coordinator, mesh.coordinator),
     };
 }
@@ -461,18 +351,16 @@ export function applyRepoMeshConfig<T extends Pick<LocalMeshEntry, 'policy' | 'c
 /**
  * Build a `.adhdev/mesh.json` DRAFT from a machine-local mesh entry. This is a
  * scaffold for the operator to review and commit — NOT an automatic migration.
- * It captures the local policy (fully normalized) plus any coordinator prompt
- * override/append so a repo can adopt the current machine's settings as the
- * shared base. Operating notes are intentionally NOT exported: those are runtime
- * ledger lessons, and a repo should declare baseline notes deliberately.
+ * It captures the coordinator prompt override/append so a repo can adopt the
+ * current machine's prompt customization as the shared base. Policy is NOT
+ * exported — it is machine-local only and has no place in mesh.json. Operating
+ * notes are intentionally NOT exported either: those are runtime ledger lessons,
+ * and a repo should declare baseline notes deliberately.
  */
 export function buildMeshJsonConfigScaffold(
-    mesh: Pick<LocalMeshEntry, 'policy' | 'coordinator'>,
+    mesh: Pick<LocalMeshEntry, 'coordinator'>,
 ): RepoMeshDeclarativeConfig {
-    const scaffold: RepoMeshDeclarativeConfig = {
-        version: 1,
-        policy: mergeAndNormalizePolicy(undefined, mesh.policy),
-    };
+    const scaffold: RepoMeshDeclarativeConfig = { version: 1 };
     const coord: RepoMeshDeclarativeCoordinatorConfig = {};
     const override = mesh.coordinator?.systemPromptOverride;
     if (typeof override === 'string' && override.trim()) coord.systemPromptOverride = override;
@@ -486,132 +374,3 @@ export function buildMeshJsonConfigScaffold(
 export function serializeMeshJsonConfigScaffold(config: RepoMeshDeclarativeConfig): string {
     return JSON.stringify(config, null, 2);
 }
-
-// ─── Scheduling overlay: validate / load ────────
-
-/**
- * Validate a parsed `.adhdev/mesh.*` document into a MeshJsonConfig (scheduling
- * overlay). Tolerant of an empty/partial file (an empty object is valid and
- * yields no overlay); strict about malformed values so a typo surfaces as
- * `invalid` rather than silently no-op'ing.
- */
-export function validateMeshJsonConfig(raw: unknown, source = 'inline'): { valid: boolean; errors: string[]; config?: MeshJsonConfig } {
-    const errors: string[] = [];
-    if (!isRecord(raw)) {
-        return { valid: false, errors: [`${source}: config must be an object`] };
-    }
-    const config: MeshJsonConfig = {};
-
-    const policy = raw.policy;
-    const schedulingRaw = isRecord(policy) ? policy.scheduling : undefined;
-    if (schedulingRaw !== undefined) {
-        if (!isRecord(schedulingRaw)) {
-            errors.push('policy.scheduling must be an object');
-        } else {
-            const scheduling: MeshJsonSchedulingConfig = {};
-            if (schedulingRaw.distribution !== undefined) {
-                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 !== undefined) {
-                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 !== undefined) {
-                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);
-                }
-            }
-            // Reject unknown keys inside the scheduling block to catch typos early.
-            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 : undefined };
-}
-
-// mtime-keyed cache: the scheduler re-reads on every reconcile tick (~4s), so cache
-// the parse result and only re-read when the file's mtime (or its presence) changes.
-const cache = new Map<string, { sourceKey: string; result: MeshJsonConfigLoadResult }>();
-
-/**
- * Locate and load the `.adhdev/mesh.json` scheduling overlay for a repo root.
- * Declarative only — never executes config. Cached by path + mtime so repeated
- * scheduler reads are cheap.
- */
-export function loadMeshJsonConfig(repoRoot: string): MeshJsonConfigLoadResult {
-    if (!repoRoot) {
-        return { source: 'unavailable', sourceType: 'unavailable', error: 'no repo root', sourceKey: 'unavailable' };
-    }
-    for (const relative of MESH_JSON_CONFIG_LOCATIONS) {
-        const configPath = join(repoRoot, relative);
-        if (!existsSync(configPath)) continue;
-        let mtimeMs = 0;
-        try {
-            mtimeMs = statSync(configPath).mtimeMs;
-        } catch {
-            mtimeMs = 0;
-        }
-        const cacheKey = configPath;
-        const sourceKey = `file:${configPath}:${mtimeMs}`;
-        const cached = cache.get(cacheKey);
-        if (cached && cached.sourceKey === sourceKey) return cached.result;
-        let result: MeshJsonConfigLoadResult;
-        try {
-            const text = readFileSync(configPath, 'utf-8');
-            const parsed = parseConfigText(configPath, text);
-            const validation = validateMeshJsonConfig(parsed, relative);
-            result = validation.valid
-                ? { config: validation.config, source: relative, sourceType: 'repo_file', path: configPath, sourceKey }
-                : { source: relative, sourceType: 'invalid', path: configPath, error: validation.errors.join('; '), sourceKey: `invalid:${configPath}:${mtimeMs}` };
-        } catch (error: any) {
-            result = { source: relative, 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',
-    };
-}
-
-/** Test-only: drop the mtime cache so a per-run temp file is re-read. */
-export function __resetMeshJsonConfigCacheForTests(): void {
-    cache.clear();
-}
-
-/**
- * The effective scheduling knobs after layering the repo-local `.adhdev/mesh.json`
- * overlay on top of a stored mesh policy (LOCAL-WINS). This is the single resolution
- * point the scheduler reads, so the strategy/caps it acts on always reflect the
- * in-tree override when present and fall back to the persisted policy otherwise.
- */
-export interface EffectiveMeshScheduling {
-    /** Resolved raw strategy (override distribution → strategy, else stored policy). */
-    strategy: ReturnType<typeof distributionToStrategy> | RepoMeshPolicy['schedulingStrategy'];
-    /** Effective, clamped global write cap. */
-    maxParallelTasks: number;
-    /** Read-only cap multiplier (override, else default 2). */
-    readonlyMultiplier?: number;
-    /** True when an `.adhdev/mesh.json` overlay actually contributed a value. */
-    overrideApplied: boolean;
-}