@pleri/olam-cli 0.1.199 → 0.1.201

package/dist/mcp-server.js

@@ -7090,7 +7090,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve15.call(this, root, ref);
+      let _sch = resolve16.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a3 = root.localRefs) === null || _a3 === void 0 ? void 0 : _a3[ref];
         const { schemaId } = this.opts;
@@ -7117,7 +7117,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve15(root, ref) {
+    function resolve16(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -7692,7 +7692,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve15(baseURI, relativeURI, options) {
+    function resolve16(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse4(baseURI, schemelessOptions), parse4(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -7919,7 +7919,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve15,
+      resolve: resolve16,
       resolveComponent,
       equal,
       serialize,
@@ -10895,12 +10895,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs55, exportName) {
+    function addFormats(ajv, list, fs56, exportName) {
       var _a3;
       var _b;
       (_a3 = (_b = ajv.opts.code).formats) !== null && _a3 !== void 0 ? _a3 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs55[f]);
+        ajv.addFormat(f, fs56[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -12143,7 +12143,7 @@ var init_schema4 = __esm({
       env: external_exports.record(external_exports.string().min(1), external_exports.record(external_exports.string().min(1), external_exports.string())).optional(),
       updatedAt: external_exports.number().int().nonnegative()
     });
-    MetaHookBlockKindSchema = external_exports.enum(["memory-recall", "memory-classify"]);
+    MetaHookBlockKindSchema = external_exports.enum(["memory-recall", "memory-classify", "model-router"]);
     GlobalConfigSchema = external_exports.object({
       schemaVersion: external_exports.literal(1),
       repos: external_exports.array(RepoEntrySchema).optional().default([]),
@@ -13854,17 +13854,143 @@ var init_memory_classify = __esm({
   }
 });
 
+// ../core/dist/meta-hooks/model-router.js
+import * as fs26 from "node:fs";
+function buildModelRouterHookEntry() {
+  return {
+    hooks: [
+      {
+        type: "command",
+        command: `OLAM_META_SENTINEL=${OLAM_META_MODEL_ROUTER_SENTINEL}; ${OLAM_META_NOOP_GUARD3} python3 "${OLAM_META_MODEL_ROUTER_SCRIPT_PATH}"`,
+        timeout: OLAM_META_MODEL_ROUTER_TIMEOUT_MS
+      }
+    ]
+  };
+}
+function computeModelRouterUninstall(settings) {
+  const matchers = settings.hooks?.UserPromptSubmit;
+  if (!Array.isArray(matchers) || matchers.length === 0) {
+    return { status: "not-found" };
+  }
+  let changed = false;
+  const filteredMatchers = [];
+  for (const matcher of matchers) {
+    const innerHooks = matcher.hooks ?? [];
+    const keptInner = innerHooks.filter((h) => {
+      if (typeof h.command === "string" && h.command.includes(OLAM_META_MODEL_ROUTER_SENTINEL)) {
+        changed = true;
+        return false;
+      }
+      return true;
+    });
+    if (keptInner.length === 0 && innerHooks.length > 0) {
+      changed = true;
+      continue;
+    }
+    if (keptInner.length === innerHooks.length) {
+      filteredMatchers.push(matcher);
+    } else {
+      filteredMatchers.push({ ...matcher, hooks: keptInner });
+    }
+  }
+  if (!changed)
+    return { status: "not-found" };
+  const next = {
+    ...settings,
+    hooks: {
+      ...settings.hooks,
+      UserPromptSubmit: filteredMatchers
+    }
+  };
+  if (filteredMatchers.length === 0) {
+    const otherStages = Object.keys(next.hooks ?? {}).filter((k) => k !== "UserPromptSubmit");
+    if (otherStages.length === 0) {
+      delete next.hooks;
+    } else {
+      delete next.hooks.UserPromptSubmit;
+    }
+  }
+  return { status: "removed", settingsAfter: next };
+}
+function matchModelRouterSentinel(commandLine) {
+  return commandLine.includes(OLAM_META_MODEL_ROUTER_SENTINEL);
+}
+var OLAM_META_MODEL_ROUTER_SENTINEL, OLAM_META_MODEL_ROUTER_STAGE, OLAM_META_MODEL_ROUTER_TIMEOUT_MS, OLAM_META_MODEL_ROUTER_SCRIPT_PATH, OLAM_META_MODEL_ROUTER_SCRIPT_BASENAME, OLAM_META_NOOP_GUARD3;
+var init_model_router = __esm({
+  "../core/dist/meta-hooks/model-router.js"() {
+    "use strict";
+    OLAM_META_MODEL_ROUTER_SENTINEL = "olam-meta-model-router-v1";
+    OLAM_META_MODEL_ROUTER_STAGE = "UserPromptSubmit";
+    OLAM_META_MODEL_ROUTER_TIMEOUT_MS = 5e3;
+    OLAM_META_MODEL_ROUTER_SCRIPT_PATH = "$HOME/.claude/hooks/model-router.py";
+    OLAM_META_MODEL_ROUTER_SCRIPT_BASENAME = "model-router.py";
+    OLAM_META_NOOP_GUARD3 = "command -v olam >/dev/null 2>&1 || exit 0;";
+  }
+});
+
+// ../core/dist/meta-hooks/model-router-deploy.js
+import { existsSync as existsSync28, mkdirSync as mkdirSync16, readFileSync as readFileSync22, writeFileSync as writeFileSync14 } from "node:fs";
+import { homedir as homedir16 } from "node:os";
+import { dirname as dirname13, join as join24, resolve as resolve7 } from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
+function resolveModelRouterSourcePath() {
+  const here = dirname13(fileURLToPath3(import.meta.url));
+  const candidates = [
+    // (1) in-repo tsc dist: core/dist/meta-hooks → ../../../cli/hooks
+    resolve7(here, "..", "..", "..", "cli", "hooks", MODEL_ROUTER_SCRIPT_BASENAME),
+    // (1b) in-repo src (tsx / vitest): core/src/meta-hooks → ../../../cli/hooks
+    resolve7(here, "..", "..", "..", "cli", "hooks", MODEL_ROUTER_SCRIPT_BASENAME),
+    // (2) bundled CLI: dist/<bundle> → ../hooks (hooks is sibling of dist)
+    resolve7(here, "..", "hooks", MODEL_ROUTER_SCRIPT_BASENAME),
+    resolve7(here, "..", "..", "hooks", MODEL_ROUTER_SCRIPT_BASENAME)
+  ];
+  for (const candidate of candidates) {
+    if (existsSync28(candidate))
+      return candidate;
+  }
+  return candidates[0];
+}
+function deployModelRouterScript(opts = {}) {
+  const targetDir = opts.targetDir ?? join24(homedir16(), ".claude", "hooks");
+  const targetPath = join24(targetDir, MODEL_ROUTER_SCRIPT_BASENAME);
+  const sourcePath = opts.sourcePath ?? resolveModelRouterSourcePath();
+  if (!existsSync28(sourcePath)) {
+    return { basename: MODEL_ROUTER_SCRIPT_BASENAME, action: "source-missing", targetPath };
+  }
+  const newContent = readFileSync22(sourcePath, "utf8");
+  if (existsSync28(targetPath)) {
+    const existing = readFileSync22(targetPath, "utf8");
+    if (existing === newContent) {
+      return { basename: MODEL_ROUTER_SCRIPT_BASENAME, action: "unchanged", targetPath };
+    }
+  }
+  if (opts.dryRun !== true) {
+    mkdirSync16(dirname13(targetPath), { recursive: true });
+    writeFileSync14(targetPath, newContent, { mode: 493 });
+  }
+  return { basename: MODEL_ROUTER_SCRIPT_BASENAME, action: "written", targetPath };
+}
+var MODEL_ROUTER_SCRIPT_BASENAME;
+var init_model_router_deploy = __esm({
+  "../core/dist/meta-hooks/model-router-deploy.js"() {
+    "use strict";
+    MODEL_ROUTER_SCRIPT_BASENAME = "model-router.py";
+  }
+});
+
 // ../core/dist/meta-hooks/index.js
 var init_meta_hooks = __esm({
   "../core/dist/meta-hooks/index.js"() {
     "use strict";
     init_memory_recall();
     init_memory_classify();
+    init_model_router();
+    init_model_router_deploy();
   }
 });
 
 // ../core/dist/skill-sync/settings-merger.js
-import * as fs26 from "node:fs";
+import * as fs27 from "node:fs";
 import * as os16 from "node:os";
 import * as path25 from "node:path";
 function claudeSettingsPath() {
@@ -13933,28 +14059,28 @@ function tagOlam(entry) {
   return { ...entry, [OLAM_SKILLS_MARKER]: true };
 }
 function readJson(file) {
-  return JSON.parse(fs26.readFileSync(file, "utf-8"));
+  return JSON.parse(fs27.readFileSync(file, "utf-8"));
 }
 function rotateBackups(backupDir) {
-  if (!fs26.existsSync(backupDir))
+  if (!fs27.existsSync(backupDir))
     return;
-  const files = fs26.readdirSync(backupDir).filter((f) => f.endsWith(".json")).map((f) => ({ name: f, full: path25.join(backupDir, f), mtime: fs26.statSync(path25.join(backupDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const files = fs27.readdirSync(backupDir).filter((f) => f.endsWith(".json")).map((f) => ({ name: f, full: path25.join(backupDir, f), mtime: fs27.statSync(path25.join(backupDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   for (const f of files.slice(BACKUP_RETENTION)) {
     try {
-      fs26.unlinkSync(f.full);
+      fs27.unlinkSync(f.full);
     } catch {
     }
   }
 }
 function backupSettings() {
   const src = claudeSettingsPath();
-  if (!fs26.existsSync(src))
+  if (!fs27.existsSync(src))
     return void 0;
   const dir = settingsBackupDir();
-  fs26.mkdirSync(dir, { recursive: true });
+  fs27.mkdirSync(dir, { recursive: true });
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const dest = path25.join(dir, `settings-${stamp}.json`);
-  fs26.copyFileSync(src, dest);
+  fs27.copyFileSync(src, dest);
   rotateBackups(dir);
   return dest;
 }
@@ -13962,7 +14088,7 @@ function mergeSettings(input) {
   const settingsPath = claudeSettingsPath();
   const backupPath = backupSettings();
   let base = {};
-  if (fs26.existsSync(settingsPath)) {
+  if (fs27.existsSync(settingsPath)) {
     try {
       base = readJson(settingsPath);
     } catch {
@@ -14030,10 +14156,10 @@ function mergeSettings(input) {
       ...input.permissionFiles.length > 0 ? { allow: [...permSet] } : {}
     }
   };
-  fs26.mkdirSync(path25.dirname(settingsPath), { recursive: true });
+  fs27.mkdirSync(path25.dirname(settingsPath), { recursive: true });
   const tmp = `${settingsPath}.tmp-${process.pid}`;
-  fs26.writeFileSync(tmp, JSON.stringify(next, null, 2) + "\n", { mode: 420 });
-  fs26.renameSync(tmp, settingsPath);
+  fs27.writeFileSync(tmp, JSON.stringify(next, null, 2) + "\n", { mode: 420 });
+  fs27.renameSync(tmp, settingsPath);
   return { backupPath, hooksAdded, permissionsCount: permSet.size, dualWriteDeduped, dualWriteDroppedCommands };
 }
 var OLAM_SKILLS_MARKER, BACKUP_RETENTION, DUAL_WRITE_DEDUP_RULES;
@@ -14090,7 +14216,7 @@ var init_schema5 = __esm({
 
 // ../core/dist/skill-sync/per-project-override.js
 import { execFileSync as execFileSync3 } from "node:child_process";
-import * as fs27 from "node:fs";
+import * as fs28 from "node:fs";
 import * as path26 from "node:path";
 import { parse as parseYaml3 } from "yaml";
 function findProjectOverride(startDir) {
@@ -14098,8 +14224,8 @@ function findProjectOverride(startDir) {
   const root = path26.parse(dir).root;
   while (true) {
     const candidate = path26.join(dir, PROJECT_OVERRIDE_RELATIVE_PATH);
-    if (fs27.existsSync(candidate) && fs27.statSync(candidate).isFile()) {
-      const raw = fs27.readFileSync(candidate, "utf-8");
+    if (fs28.existsSync(candidate) && fs28.statSync(candidate).isFile()) {
+      const raw = fs28.readFileSync(candidate, "utf-8");
       let parsed;
       try {
         parsed = parseYaml3(raw);
@@ -14158,7 +14284,7 @@ var init_per_project_override = __esm({
 });
 
 // ../core/dist/lib/file-lock.js
-import * as fs28 from "node:fs";
+import * as fs29 from "node:fs";
 import * as os17 from "node:os";
 import * as path27 from "node:path";
 function defaultIsPidAlive(pid) {
@@ -14171,11 +14297,11 @@ function defaultIsPidAlive(pid) {
   }
 }
 function sleep3(ms) {
-  return new Promise((resolve15) => setTimeout(resolve15, ms));
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
 function readLockMeta(lockPath) {
   try {
-    const raw = fs28.readFileSync(lockPath, "utf-8");
+    const raw = fs29.readFileSync(lockPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.pid === "number" && typeof parsed?.hostname === "string" && typeof parsed?.timestamp === "number") {
       return parsed;
@@ -14194,12 +14320,12 @@ function isLockStale(meta2, opts) {
 }
 function tryAcquireOnce(lockPath, meta2, opts) {
   try {
-    fs28.mkdirSync(path27.dirname(lockPath), { recursive: true });
-    const fd = fs28.openSync(lockPath, "wx", 384);
+    fs29.mkdirSync(path27.dirname(lockPath), { recursive: true });
+    const fd = fs29.openSync(lockPath, "wx", 384);
     try {
-      fs28.writeSync(fd, JSON.stringify(meta2));
+      fs29.writeSync(fd, JSON.stringify(meta2));
     } finally {
-      fs28.closeSync(fd);
+      fs29.closeSync(fd);
     }
     return true;
   } catch (err) {
@@ -14209,14 +14335,14 @@ function tryAcquireOnce(lockPath, meta2, opts) {
     const existing = readLockMeta(lockPath);
     if (existing === void 0) {
       try {
-        fs28.unlinkSync(lockPath);
+        fs29.unlinkSync(lockPath);
       } catch {
       }
       return tryAcquireOnce(lockPath, meta2, opts);
     }
     if (isLockStale(existing, opts)) {
       try {
-        fs28.unlinkSync(lockPath);
+        fs29.unlinkSync(lockPath);
       } catch {
       }
       return tryAcquireOnce(lockPath, meta2, opts);
@@ -14246,7 +14372,7 @@ async function acquireFileLock(lockDir, options = {}) {
         lockPath,
         release: () => {
           try {
-            fs28.unlinkSync(lockPath);
+            fs29.unlinkSync(lockPath);
           } catch {
           }
         }
@@ -14286,13 +14412,13 @@ var init_file_lock = __esm({
 });
 
 // ../core/dist/lib/min-version-filter.js
-import { existsSync as existsSync29, readFileSync as readFileSync24 } from "node:fs";
+import { existsSync as existsSync31, readFileSync as readFileSync26 } from "node:fs";
 function readOlamMinVersion(filepath) {
-  if (!existsSync29(filepath))
+  if (!existsSync31(filepath))
     return void 0;
   let text;
   try {
-    text = readFileSync24(filepath, "utf8");
+    text = readFileSync26(filepath, "utf8");
   } catch {
     return void 0;
   }
@@ -14350,11 +14476,11 @@ var init_min_version_filter = __esm({
 });
 
 // ../core/dist/skill-sync/overlay-scan.js
-import * as fs29 from "node:fs";
+import * as fs30 from "node:fs";
 import * as path28 from "node:path";
 function scanOverlayReferences(overlayRoot, basenames, caps = DEFAULT_CAPS) {
   const result = /* @__PURE__ */ new Map();
-  if (!fs29.existsSync(overlayRoot)) {
+  if (!fs30.existsSync(overlayRoot)) {
     return result;
   }
   if (basenames.length === 0) {
@@ -14363,13 +14489,13 @@ function scanOverlayReferences(overlayRoot, basenames, caps = DEFAULT_CAPS) {
   const mdFiles = [];
   let overlayRootReal;
   try {
-    overlayRootReal = fs29.realpathSync(overlayRoot);
+    overlayRootReal = fs30.realpathSync(overlayRoot);
   } catch {
     return result;
   }
   for (const subdir of OVERRIDE_SUBDIRS) {
     const dir = path28.join(overlayRoot, subdir);
-    if (!fs29.existsSync(dir))
+    if (!fs30.existsSync(dir))
       continue;
     walkMarkdown(dir, mdFiles, caps.maxFiles);
   }
@@ -14377,7 +14503,7 @@ function scanOverlayReferences(overlayRoot, basenames, caps = DEFAULT_CAPS) {
   for (const filepath of mdFiles) {
     let realFile;
     try {
-      realFile = fs29.realpathSync(filepath);
+      realFile = fs30.realpathSync(filepath);
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT" || code === "EACCES")
@@ -14390,12 +14516,12 @@ function scanOverlayReferences(overlayRoot, basenames, caps = DEFAULT_CAPS) {
     }
     let content;
     try {
-      const stat2 = fs29.statSync(filepath);
+      const stat2 = fs30.statSync(filepath);
       totalBytes += stat2.size;
       if (totalBytes > caps.maxTotalBytes) {
         throw new Error(`[overlay-scan] aborted: overlay tree exceeds ${caps.maxTotalBytes} total bytes. Check OLAM_CLAUDE_DIR / overlay paths are correctly scoped.`);
       }
-      content = fs29.readFileSync(filepath, "utf8");
+      content = fs30.readFileSync(filepath, "utf8");
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT" || code === "EACCES") {
@@ -14417,7 +14543,7 @@ function scanOverlayReferences(overlayRoot, basenames, caps = DEFAULT_CAPS) {
 function walkMarkdown(dir, out, cap) {
   let entries;
   try {
-    entries = fs29.readdirSync(dir, { withFileTypes: true });
+    entries = fs30.readdirSync(dir, { withFileTypes: true });
   } catch (err) {
     if (err.code === "ENOENT")
       return;
@@ -14452,7 +14578,7 @@ var init_overlay_scan = __esm({
 });
 
 // ../core/dist/skill-sync/settings-json-lock.js
-import * as fs30 from "node:fs";
+import * as fs31 from "node:fs";
 import * as os18 from "node:os";
 import * as path29 from "node:path";
 function defaultSettingsJsonLockPath() {
@@ -14469,11 +14595,11 @@ function defaultIsPidAlive2(pid) {
   }
 }
 function sleep4(ms) {
-  return new Promise((resolve15) => setTimeout(resolve15, ms));
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
 function readLockMeta2(lockPath) {
   try {
-    const raw = fs30.readFileSync(lockPath, "utf-8");
+    const raw = fs31.readFileSync(lockPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.pid === "number" && typeof parsed?.hostname === "string" && typeof parsed?.timestamp === "number") {
       return parsed;
@@ -14496,12 +14622,12 @@ function isLockStale2(meta2, opts) {
 function tryAcquireOnce2(lockPath, meta2, opts) {
   for (let attempt = 0; attempt <= MAX_STEAL_ATTEMPTS; attempt += 1) {
     try {
-      fs30.mkdirSync(path29.dirname(lockPath), { recursive: true });
-      const fd = fs30.openSync(lockPath, "wx", 384);
+      fs31.mkdirSync(path29.dirname(lockPath), { recursive: true });
+      const fd = fs31.openSync(lockPath, "wx", 384);
       try {
-        fs30.writeSync(fd, JSON.stringify(meta2));
+        fs31.writeSync(fd, JSON.stringify(meta2));
       } finally {
-        fs30.closeSync(fd);
+        fs31.closeSync(fd);
       }
       return true;
     } catch (err) {
@@ -14519,9 +14645,9 @@ function tryAcquireOnce2(lockPath, meta2, opts) {
     }
     const victimPath = `${lockPath}.victim-${process.pid}-${attempt}-${Date.now()}`;
     try {
-      fs30.renameSync(lockPath, victimPath);
+      fs31.renameSync(lockPath, victimPath);
       try {
-        fs30.unlinkSync(victimPath);
+        fs31.unlinkSync(victimPath);
       } catch {
       }
     } catch (err) {
@@ -14553,7 +14679,7 @@ async function acquireSettingsJsonLock(options = {}) {
         lockPath,
         release: () => {
           try {
-            fs30.unlinkSync(lockPath);
+            fs31.unlinkSync(lockPath);
           } catch {
           }
         }
@@ -14656,7 +14782,7 @@ var init_services_status = __esm({
 
 // ../core/dist/skill-sources/meta-hooks-migration-snapshot.js
 import * as crypto5 from "node:crypto";
-import * as fs31 from "node:fs";
+import * as fs32 from "node:fs";
 import * as os19 from "node:os";
 import * as path30 from "node:path";
 function migrationSnapshotsDir2() {
@@ -14674,11 +14800,11 @@ function writeMetaHooksSnapshot(originalSettings) {
   };
   const validated = MetaHooksMigrationSnapshotSchema.parse(snapshot);
   const dir = migrationSnapshotsDir2();
-  fs31.mkdirSync(dir, { recursive: true });
+  fs32.mkdirSync(dir, { recursive: true });
   const stamp = validated.takenAt.replace(/[:.]/g, "-");
   const rand = crypto5.randomBytes(3).toString("hex");
   const file = path30.join(dir, `${META_HOOKS_SNAPSHOT_PREFIX}${stamp}-${process.pid}-${rand}.json`);
-  fs31.writeFileSync(file, JSON.stringify(validated, null, 2) + "\n", { mode: 384 });
+  fs32.writeFileSync(file, JSON.stringify(validated, null, 2) + "\n", { mode: 384 });
   return file;
 }
 var META_HOOKS_SNAPSHOT_SCHEMA_VERSION, META_HOOKS_SNAPSHOT_PREFIX, SettingsLooseSchema, MetaHooksMigrationSnapshotSchema;
@@ -14819,6 +14945,8 @@ function decideTargetBlocks(opts) {
     target.add("memory-recall");
   if (wantMemory && !disabled.has("memory-classify"))
     target.add("memory-classify");
+  if (!disabled.has("model-router"))
+    target.add("model-router");
   return target;
 }
 function injectMetaHooks(opts) {
@@ -14826,6 +14954,7 @@ function injectMetaHooks(opts) {
   let working = JSON.parse(JSON.stringify(opts.currentSettings ?? {}));
   const blocksAdded = [];
   const blocksRemoved = [];
+  const blocksSkippedForeign = [];
   const memoryRecallPresent = hasMemoryRecallBlock(working);
   if (target.has("memory-recall")) {
     if (!memoryRecallPresent) {
@@ -14856,10 +14985,30 @@ function injectMetaHooks(opts) {
       }
     }
   }
+  const modelRouterPresent = hasModelRouterBlock(working);
+  if (target.has("model-router")) {
+    if (!modelRouterPresent) {
+      if (hasForeignModelRouterEntry(working)) {
+        blocksSkippedForeign.push("model-router");
+      } else {
+        working = appendBlock(working, OLAM_META_MODEL_ROUTER_STAGE, buildModelRouterHookEntry());
+        blocksAdded.push("model-router");
+      }
+    }
+  } else {
+    if (modelRouterPresent) {
+      const r = computeModelRouterUninstall(working);
+      if (r.status === "removed" && r.settingsAfter) {
+        working = r.settingsAfter;
+        blocksRemoved.push("model-router");
+      }
+    }
+  }
   return {
     nextSettings: working,
     blocksAdded,
     blocksRemoved,
+    blocksSkippedForeign,
     mode: opts.mode ?? "auto"
   };
 }
@@ -14893,6 +15042,40 @@ function hasMemoryClassifyBlock(settings) {
   }
   return false;
 }
+function hasModelRouterBlock(settings) {
+  const entries = settings.hooks?.UserPromptSubmit;
+  if (!Array.isArray(entries))
+    return false;
+  for (const matcher of entries) {
+    const inner = matcher?.hooks ?? [];
+    if (!Array.isArray(inner))
+      continue;
+    for (const h of inner) {
+      if (typeof h?.command === "string" && matchModelRouterSentinel(h.command))
+        return true;
+    }
+  }
+  return false;
+}
+function hasForeignModelRouterEntry(settings) {
+  const entries = settings.hooks?.UserPromptSubmit;
+  if (!Array.isArray(entries))
+    return false;
+  for (const matcher of entries) {
+    const inner = matcher?.hooks ?? [];
+    if (!Array.isArray(inner))
+      continue;
+    for (const h of inner) {
+      if (typeof h?.command !== "string")
+        continue;
+      if (matchModelRouterSentinel(h.command))
+        continue;
+      if (h.command.includes(OLAM_META_MODEL_ROUTER_SCRIPT_BASENAME))
+        return true;
+    }
+  }
+  return false;
+}
 function appendBlock(settings, stage, entry) {
   const next = { ...settings };
   const hooks = { ...settings.hooks ?? {} };
@@ -14911,7 +15094,7 @@ var init_meta_hook_injector = __esm({
 
 // ../core/dist/lib/markdown-merger.js
 import { createHash as createHash5 } from "node:crypto";
-import { readFileSync as readFileSync28, existsSync as existsSync32, statSync as statSync8 } from "node:fs";
+import { readFileSync as readFileSync30, existsSync as existsSync34, statSync as statSync8 } from "node:fs";
 function parseFrontmatter(text) {
   const match = FM_RE2.exec(text);
   if (match === null)
@@ -15040,9 +15223,9 @@ function mergeMarkdown(upstreamText, overlayText, labelForError, upstreamPath, o
   return { merged: fmBlock !== "" ? fmBlock + mergedBody : mergedBody };
 }
 function sha256OfPath(p) {
-  if (!existsSync32(p) || !statSync8(p).isFile())
+  if (!existsSync34(p) || !statSync8(p).isFile())
     return "MISSING";
-  return createHash5("sha256").update(readFileSync28(p)).digest("hex");
+  return createHash5("sha256").update(readFileSync30(p)).digest("hex");
 }
 var FM_RE2, H2_RE;
 var init_markdown_merger = __esm({
@@ -15054,7 +15237,7 @@ var init_markdown_merger = __esm({
 });
 
 // ../core/dist/skill-sync/managed-merge.js
-import * as fs32 from "node:fs";
+import * as fs33 from "node:fs";
 import * as path31 from "node:path";
 function materializeMergedSkill(opts) {
   const { sourceId, sourcePath, deployBasename, mergedContent, claudeDir: claudeDir2 } = opts;
@@ -15064,12 +15247,12 @@ function materializeMergedSkill(opts) {
   if (!(managedResolved === sourceRoot || managedResolved.startsWith(sourceRoot + path31.sep))) {
     throw new Error(`[managed-merge] refusing to materialize: deployBasename "${deployBasename}" escapes managed root "${sourceRoot}" (resolved to "${managedResolved}")`);
   }
-  fs32.mkdirSync(managedDir, { recursive: true });
+  fs33.mkdirSync(managedDir, { recursive: true });
   const skillMdPath = path31.join(managedDir, "SKILL.md");
   const tmpPath = `${skillMdPath}.tmp-${process.pid}-${Date.now()}`;
-  fs32.writeFileSync(tmpPath, mergedContent);
-  fs32.renameSync(tmpPath, skillMdPath);
-  const baseEntries = fs32.readdirSync(sourcePath);
+  fs33.writeFileSync(tmpPath, mergedContent);
+  fs33.renameSync(tmpPath, skillMdPath);
+  const baseEntries = fs33.readdirSync(sourcePath);
   for (const entry of baseEntries) {
     if (entry === "SKILL.md")
       continue;
@@ -15077,13 +15260,13 @@ function materializeMergedSkill(opts) {
     const targetAbsolute = path31.join(sourcePath, entry);
     const targetRelative = path31.relative(managedDir, targetAbsolute);
     try {
-      fs32.lstatSync(linkPath);
-      fs32.rmSync(linkPath, { recursive: true, force: true });
+      fs33.lstatSync(linkPath);
+      fs33.rmSync(linkPath, { recursive: true, force: true });
     } catch {
     }
-    fs32.symlinkSync(targetRelative, linkPath);
+    fs33.symlinkSync(targetRelative, linkPath);
   }
-  const managedEntries = fs32.readdirSync(managedDir);
+  const managedEntries = fs33.readdirSync(managedDir);
   const baseEntrySet = new Set(baseEntries);
   for (const entry of managedEntries) {
     if (entry === "SKILL.md")
@@ -15091,7 +15274,7 @@ function materializeMergedSkill(opts) {
     if (!baseEntrySet.has(entry)) {
       const stalePath = path31.join(managedDir, entry);
       try {
-        fs32.rmSync(stalePath, { recursive: true, force: true });
+        fs33.rmSync(stalePath, { recursive: true, force: true });
       } catch {
       }
     }
@@ -15099,7 +15282,7 @@ function materializeMergedSkill(opts) {
   return managedDir;
 }
 function cleanMergedDir(claudeDir2) {
-  fs32.rmSync(path31.join(claudeDir2, ".olam-merged"), { recursive: true, force: true });
+  fs33.rmSync(path31.join(claudeDir2, ".olam-merged"), { recursive: true, force: true });
 }
 var init_managed_merge = __esm({
   "../core/dist/skill-sync/managed-merge.js"() {
@@ -15197,7 +15380,7 @@ var init_prefix_rules = __esm({
 });
 
 // ../core/dist/skill-sync/prefix-deploy.js
-import * as fs33 from "node:fs";
+import * as fs34 from "node:fs";
 import * as path32 from "node:path";
 function buildSourcePrefixMap(sources) {
   const byId = /* @__PURE__ */ new Map();
@@ -15253,7 +15436,7 @@ function applyPrefixRewrites(baseArtifacts, sourceMap, claudeDir2, dryRun) {
     }
     if (artifact.kind === "skill") {
       const skillMdPath = path32.join(artifact.sourcePath, "SKILL.md");
-      const content = fs33.readFileSync(skillMdPath);
+      const content = fs34.readFileSync(skillMdPath);
       const rewritten = rewriteFrontmatterName(content, () => renamedFrontmatterName);
       const managedDir = materializeMergedSkill({
         sourceId: artifact.sourceId,
@@ -15265,7 +15448,7 @@ function applyPrefixRewrites(baseArtifacts, sourceMap, claudeDir2, dryRun) {
       artifact.sourcePath = managedDir;
       artifact.deployBasename = renamed;
     } else {
-      const content = artifact.resolvedContent !== void 0 ? artifact.resolvedContent : fs33.readFileSync(artifact.sourcePath);
+      const content = artifact.resolvedContent !== void 0 ? artifact.resolvedContent : fs34.readFileSync(artifact.sourcePath);
       const rewritten = rewriteFrontmatterName(content, () => renamedFrontmatterName);
       artifact.resolvedContent = rewritten;
       artifact.deployBasename = renamed;
@@ -15310,19 +15493,19 @@ var init_prefix_deploy = __esm({
 });
 
 // ../core/dist/skill-sync/resolve-source-config.js
-import { readFileSync as readFileSync30, existsSync as existsSync33 } from "node:fs";
-import { join as join32 } from "node:path";
+import { readFileSync as readFileSync32, existsSync as existsSync35 } from "node:fs";
+import { join as join33 } from "node:path";
 import { parse as parseYaml4 } from "yaml";
 function sourceConfigPath(clonePath) {
-  return join32(clonePath, "shared", "source-config.yaml");
+  return join33(clonePath, "shared", "source-config.yaml");
 }
 function readSourceConfig(clonePath, sourceId) {
   const path56 = sourceConfigPath(clonePath);
-  if (!existsSync33(path56))
+  if (!existsSync35(path56))
     return void 0;
   let raw;
   try {
-    raw = readFileSync30(path56, "utf-8");
+    raw = readFileSync32(path56, "utf-8");
   } catch (err) {
     emitMalformedWarning(sourceId, `read failed: ${errToMsg(err)}`);
     return void 0;
@@ -15417,7 +15600,7 @@ var init_resolve_source_config = __esm({
 });
 
 // ../core/dist/skill-sync/engine.js
-import * as fs34 from "node:fs";
+import * as fs35 from "node:fs";
 import * as os20 from "node:os";
 import * as path33 from "node:path";
 function resolveAtlasUser(override) {
@@ -15425,8 +15608,8 @@ function resolveAtlasUser(override) {
     return override;
   const claudeDir2 = process.env["OLAM_CLAUDE_DIR"] || path33.join(os20.homedir(), ".claude");
   const f = path33.join(claudeDir2, ".atlas-user");
-  if (fs34.existsSync(f)) {
-    return fs34.readFileSync(f, "utf-8").trim() || void 0;
+  if (fs35.existsSync(f)) {
+    return fs35.readFileSync(f, "utf-8").trim() || void 0;
   }
   return void 0;
 }
@@ -15438,7 +15621,7 @@ async function syncSkills(opts = {}) {
   const perSource = [];
   for (const source of sources) {
     const clonePath = skillSourceClonePath(source.id);
-    if (!fs34.existsSync(clonePath))
+    if (!fs35.existsSync(clonePath))
       continue;
     const { artifacts, subscription } = await withFileLock(clonePath, () => {
       const pinRef = projectOverride?.override.pin?.[source.id];
@@ -15478,7 +15661,7 @@ async function syncSkills(opts = {}) {
   const overlayArtifacts = memberOverlaysEnabled ? projectFilteredArtifacts.filter((a) => a.kind === "overlay") : [];
   const effectiveSources = sources.map((s) => {
     const clonePath = skillSourceClonePath(s.id);
-    const sourceConfig = fs34.existsSync(clonePath) ? readSourceConfig(clonePath, s.id) : void 0;
+    const sourceConfig = fs35.existsSync(clonePath) ? readSourceConfig(clonePath, s.id) : void 0;
     const eff = resolveEffectivePrefix(s, sourceConfig);
     const entry = {
       id: s.id,
@@ -15585,12 +15768,12 @@ async function syncSkills(opts = {}) {
       let basePath;
       if (overlay.targetKind === "skill") {
         basePath = path33.join(base.sourcePath, "SKILL.md");
-        baseContent = fs34.readFileSync(basePath, "utf-8");
+        baseContent = fs35.readFileSync(basePath, "utf-8");
       } else {
         basePath = base.sourcePath;
-        baseContent = fs34.readFileSync(basePath, "utf-8");
+        baseContent = fs35.readFileSync(basePath, "utf-8");
       }
-      const overlayContent = fs34.readFileSync(overlay.sourcePath, "utf-8");
+      const overlayContent = fs35.readFileSync(overlay.sourcePath, "utf-8");
       const label = `${overlay.sourceId}/${overlay.deployBasename}`;
       const mergeResult = mergeMarkdown(baseContent, overlayContent, label, basePath, overlay.sourcePath);
       if ("error" in mergeResult) {
@@ -15672,24 +15855,34 @@ async function injectMetaHooksIntoSettings(opts) {
     ...memoryProbe.detail !== void 0 ? { memoryDetail: memoryProbe.detail } : {}
   };
   const settingsFile = claudeSettingsPath();
+  let configDisabled = [];
+  try {
+    const cfg = readGlobalConfig();
+    configDisabled = cfg.metaHooksDisabled ?? [];
+  } catch {
+  }
+  const disabledBlocks = Array.from(/* @__PURE__ */ new Set([
+    ...configDisabled,
+    ...opts.metaHooksDisabled ?? []
+  ]));
   let snapshotError;
   let stripCandidates = [];
   const result = await withSettingsJsonLock(() => {
     let currentSettings = {};
     let settingsExisted = false;
-    if (fs34.existsSync(settingsFile)) {
+    if (fs35.existsSync(settingsFile)) {
       settingsExisted = true;
       try {
-        const raw = fs34.readFileSync(settingsFile, "utf-8");
+        const raw = fs35.readFileSync(settingsFile, "utf-8");
         currentSettings = raw.trim() ? JSON.parse(raw) : {};
       } catch {
         try {
-          const raw = fs34.readFileSync(settingsFile);
+          const raw = fs35.readFileSync(settingsFile);
           const bakDir = path33.join(path33.dirname(settingsFile), ".malformed-backups");
-          fs34.mkdirSync(bakDir, { recursive: true });
+          fs35.mkdirSync(bakDir, { recursive: true });
           const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
           const bakFile = path33.join(bakDir, `settings.json.malformed.${stamp}.bak`);
-          fs34.writeFileSync(bakFile, raw, { mode: 384 });
+          fs35.writeFileSync(bakFile, raw, { mode: 384 });
           snapshotError = `settings.json was malformed; original bytes preserved at ${bakFile}`;
         } catch (bakErr) {
           snapshotError = `settings.json malformed AND .bak write failed: ${bakErr instanceof Error ? bakErr.message : String(bakErr)}`;
@@ -15700,16 +15893,6 @@ async function injectMetaHooksIntoSettings(opts) {
     }
     stripCandidates = findStripCandidates(currentSettings);
     const settingsForInject = stripCandidates.length > 0 ? applyStrip(currentSettings, stripCandidates).nextSettings : currentSettings;
-    let configDisabled = [];
-    try {
-      const cfg = readGlobalConfig();
-      configDisabled = cfg.metaHooksDisabled ?? [];
-    } catch {
-    }
-    const disabledBlocks = Array.from(/* @__PURE__ */ new Set([
-      ...configDisabled,
-      ...opts.metaHooksDisabled ?? []
-    ]));
     const inject = injectMetaHooks({
       servicesStatus,
       currentSettings: settingsForInject,
@@ -15739,17 +15922,34 @@ async function injectMetaHooksIntoSettings(opts) {
       } catch {
       }
     }
-    fs34.mkdirSync(path33.dirname(settingsFile), { recursive: true });
+    fs35.mkdirSync(path33.dirname(settingsFile), { recursive: true });
     const tmpPath = `${settingsFile}.tmp-${process.pid}-${Date.now()}`;
-    fs34.writeFileSync(tmpPath, JSON.stringify(inject.nextSettings, null, 2) + "\n");
-    fs34.renameSync(tmpPath, settingsFile);
+    fs35.writeFileSync(tmpPath, JSON.stringify(inject.nextSettings, null, 2) + "\n");
+    fs35.renameSync(tmpPath, settingsFile);
     return inject;
   }, { reason: `syncSkills meta-hook injection (mode=${mode})` });
+  let scriptDeploy;
+  const modelRouterTargeted = mode !== "never" && !disabledBlocks.includes("model-router");
+  if (modelRouterTargeted) {
+    try {
+      scriptDeploy = deployModelRouterScript({
+        targetDir: path33.join(claudeDir(), "hooks")
+      });
+    } catch (err) {
+      scriptDeploy = {
+        basename: "model-router.py",
+        action: "source-missing",
+        targetPath: `${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
   return {
     mode: result.mode,
     servicesStatus,
     blocksAdded: result.blocksAdded,
     blocksRemoved: result.blocksRemoved,
+    ...result.blocksSkippedForeign.length > 0 ? { blocksSkippedForeign: result.blocksSkippedForeign } : {},
+    ...scriptDeploy !== void 0 ? { scriptDeploy } : {},
     ...snapshotError !== void 0 ? { snapshotError } : {},
     ...stripCandidates.length > 0 ? { autoMigrated: { strippedCount: stripCandidates.length, stripCandidates } } : {}
   };
@@ -15774,6 +15974,7 @@ var init_engine = __esm({
     init_trust_audit_log();
     init_atlas_hook_strip();
     init_meta_hook_injector();
+    init_model_router_deploy();
     init_markdown_merger();
     init_managed_merge();
     init_prefix_deploy();
@@ -15783,7 +15984,7 @@ var init_engine = __esm({
 });
 
 // ../core/dist/skill-sync/shadow-backup-manager.js
-import * as fs35 from "node:fs";
+import * as fs36 from "node:fs";
 import * as path34 from "node:path";
 function listShadowBackups(opts = {}) {
   const claude = opts.claudeDirOverride ?? claudeDir();
@@ -15791,11 +15992,11 @@ function listShadowBackups(opts = {}) {
   const out = [];
   for (const bucket of SHADOW_BACKUP_BUCKETS) {
     const bucketDir = path34.join(claude, bucket);
-    if (!fs35.existsSync(bucketDir))
+    if (!fs36.existsSync(bucketDir))
       continue;
     let entries;
     try {
-      entries = fs35.readdirSync(bucketDir);
+      entries = fs36.readdirSync(bucketDir);
     } catch {
       continue;
     }
@@ -15809,7 +16010,7 @@ function listShadowBackups(opts = {}) {
       const full = path34.join(bucketDir, name);
       let sizeBytes = 0;
       try {
-        const st = fs35.statSync(full);
+        const st = fs36.statSync(full);
         if (st.isDirectory())
           continue;
         sizeBytes = st.size;
@@ -15865,7 +16066,7 @@ function pruneShadowBackups(opts) {
     }
     if (!opts.dryRun) {
       try {
-        fs35.unlinkSync(b.path);
+        fs36.unlinkSync(b.path);
       } catch {
         skipped.push(b);
         continue;
@@ -15877,7 +16078,7 @@ function pruneShadowBackups(opts) {
 }
 function restoreShadowBackup(opts) {
   const abs = path34.resolve(opts.backupPath);
-  if (!fs35.existsSync(abs)) {
+  if (!fs36.existsSync(abs)) {
     throw new Error(`backup file not found: ${abs}`);
   }
   const basename6 = path34.basename(abs);
@@ -15887,13 +16088,13 @@ function restoreShadowBackup(opts) {
   }
   const originalBasename = basename6.slice(0, basename6.length - match[0].length);
   const originalPath = path34.join(path34.dirname(abs), originalBasename);
-  if (fs35.existsSync(originalPath) && !opts.force) {
+  if (fs36.existsSync(originalPath) && !opts.force) {
     throw new Error(`original path already occupied: ${originalPath}. Move/rename it first OR re-run with --force.`);
   }
-  if (opts.force && fs35.existsSync(originalPath)) {
-    fs35.unlinkSync(originalPath);
+  if (opts.force && fs36.existsSync(originalPath)) {
+    fs36.unlinkSync(originalPath);
   }
-  fs35.renameSync(abs, originalPath);
+  fs36.renameSync(abs, originalPath);
   return { restoredTo: originalPath };
 }
 var SHADOW_BACKUP_BUCKETS, SHADOW_BACKUP_SUFFIX_RE;
@@ -15907,7 +16108,7 @@ var init_shadow_backup_manager = __esm({
 });
 
 // ../core/dist/skill-sources/doctor-checks.js
-import * as fs36 from "node:fs";
+import * as fs37 from "node:fs";
 import * as path35 from "node:path";
 import * as os21 from "node:os";
 function claudeDirInternal3() {
@@ -15923,11 +16124,11 @@ function checkStateFileParse() {
     healthy: true,
     description: `~/.olam state file (${filePath})`
   };
-  if (!fs36.existsSync(filePath)) {
+  if (!fs37.existsSync(filePath)) {
     result.details = ["(file does not yet exist \u2014 will be created on first write)"];
     return result;
   }
-  const raw = fs36.readFileSync(filePath, "utf-8");
+  const raw = fs37.readFileSync(filePath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -15937,8 +16138,8 @@ function checkStateFileParse() {
     result.details = [err instanceof Error ? err.message : String(err)];
     result.repair = () => {
       const aside = `${filePath}.corrupt-${Math.floor(Date.now() / 1e3)}`;
-      fs36.renameSync(filePath, aside);
-      fs36.writeFileSync(filePath, JSON.stringify({ schemaVersion: 1, repos: [], runbooks: [], skillSources: [] }, null, 2));
+      fs37.renameSync(filePath, aside);
+      fs37.writeFileSync(filePath, JSON.stringify({ schemaVersion: 1, repos: [], runbooks: [], skillSources: [] }, null, 2));
     };
     return result;
   }
@@ -15949,7 +16150,7 @@ function checkStateFileParse() {
     result.details = validation.error.issues.map((e) => `${e.path.join(".")}: ${e.message}`);
     result.repair = () => {
       const aside = `${filePath}.corrupt-${Math.floor(Date.now() / 1e3)}`;
-      fs36.copyFileSync(filePath, aside);
+      fs37.copyFileSync(filePath, aside);
       const base = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
       const next = {
         ...base,
@@ -15958,7 +16159,7 @@ function checkStateFileParse() {
         runbooks: [],
         skillSources: []
       };
-      fs36.writeFileSync(filePath, JSON.stringify(next, null, 2));
+      fs37.writeFileSync(filePath, JSON.stringify(next, null, 2));
     };
     return result;
   }
@@ -15970,15 +16171,15 @@ function checkDanglingSymlinks() {
   const dangling = [];
   for (const bucket of buckets) {
     const dir = path35.join(claude, bucket);
-    if (!fs36.existsSync(dir))
+    if (!fs37.existsSync(dir))
       continue;
-    for (const name of fs36.readdirSync(dir)) {
+    for (const name of fs37.readdirSync(dir)) {
       const linkPath = path35.join(dir, name);
       try {
-        const lst = fs36.lstatSync(linkPath);
+        const lst = fs37.lstatSync(linkPath);
         if (!lst.isSymbolicLink())
           continue;
-        if (!fs36.existsSync(linkPath)) {
+        if (!fs37.existsSync(linkPath)) {
           dangling.push(linkPath);
         }
       } catch {
@@ -15996,7 +16197,7 @@ function checkDanglingSymlinks() {
     result.repair = () => {
       for (const p of dangling) {
         try {
-          fs36.unlinkSync(p);
+          fs37.unlinkSync(p);
         } catch {
         }
       }
@@ -16011,19 +16212,19 @@ function checkOrphanedSnapshots() {
     healthy: true,
     description: `orphaned migration snapshots under ${dir}`
   };
-  if (!fs36.existsSync(dir)) {
+  if (!fs37.existsSync(dir)) {
     return result;
   }
   const orphans = [];
-  for (const name of fs36.readdirSync(dir)) {
+  for (const name of fs37.readdirSync(dir)) {
     if (!name.endsWith(".json"))
       continue;
     const full = path35.join(dir, name);
     try {
-      const stat2 = fs36.statSync(full);
+      const stat2 = fs37.statSync(full);
       if (!stat2.isFile())
         continue;
-      const raw = fs36.readFileSync(full, "utf-8");
+      const raw = fs37.readFileSync(full, "utf-8");
       let parsed;
       try {
         parsed = JSON.parse(raw);
@@ -16048,7 +16249,7 @@ function checkOrphanedSnapshots() {
     result.repair = () => {
       for (const o of orphans) {
         try {
-          fs36.unlinkSync(o.path);
+          fs37.unlinkSync(o.path);
         } catch {
         }
       }
@@ -16063,12 +16264,12 @@ function checkSentinelDrift() {
     healthy: true,
     description: `olam-skills sentinel block in ${filePath}`
   };
-  if (!fs36.existsSync(filePath)) {
+  if (!fs37.existsSync(filePath)) {
     return result;
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs36.readFileSync(filePath, "utf-8"));
+    parsed = JSON.parse(fs37.readFileSync(filePath, "utf-8"));
   } catch {
     return result;
   }
@@ -16109,7 +16310,7 @@ function checkSentinelDrift() {
         backupSettings();
       } catch {
       }
-      const next = JSON.parse(fs36.readFileSync(filePath, "utf-8"));
+      const next = JSON.parse(fs37.readFileSync(filePath, "utf-8"));
       if (!next.hooks)
         return;
       for (const stage of Object.keys(next.hooks)) {
@@ -16132,7 +16333,7 @@ function checkSentinelDrift() {
           return bad === void 0;
         });
       }
-      fs36.writeFileSync(filePath, JSON.stringify(next, null, 2) + "\n");
+      fs37.writeFileSync(filePath, JSON.stringify(next, null, 2) + "\n");
     };
   }
   return result;
@@ -16157,7 +16358,7 @@ function checkMemberNameMissing() {
   }
   const claudeDir2 = claudeDirInternal3();
   const atlasUserPath = path35.join(claudeDir2, ".atlas-user");
-  const value = fs36.existsSync(atlasUserPath) ? fs36.readFileSync(atlasUserPath, "utf-8").trim() : "";
+  const value = fs37.existsSync(atlasUserPath) ? fs37.readFileSync(atlasUserPath, "utf-8").trim() : "";
   if (value.length > 0) {
     result.details = [`atlas-user: ${value}`];
     return result;
@@ -16166,9 +16367,9 @@ function checkMemberNameMissing() {
   result.issue = "atlas-toolbox source registered but ~/.claude/.atlas-user not set";
   const clonePath = skillSourceClonePath(atlasSource.id);
   const membersDir = path35.join(clonePath, "members");
-  const existing = fs36.existsSync(membersDir) ? fs36.readdirSync(membersDir).filter((e) => {
+  const existing = fs37.existsSync(membersDir) ? fs37.readdirSync(membersDir).filter((e) => {
     try {
-      return fs36.statSync(path35.join(membersDir, e)).isDirectory();
+      return fs37.statSync(path35.join(membersDir, e)).isDirectory();
     } catch {
       return false;
     }
@@ -16183,7 +16384,7 @@ function checkMemberNameMissing() {
 function checkMemberOverlayDrift() {
   const claudeDir2 = claudeDirInternal3();
   const atlasUserPath = path35.join(claudeDir2, ".atlas-user");
-  const atlasUser = fs36.existsSync(atlasUserPath) ? fs36.readFileSync(atlasUserPath, "utf-8").trim() : "";
+  const atlasUser = fs37.existsSync(atlasUserPath) ? fs37.readFileSync(atlasUserPath, "utf-8").trim() : "";
   if (atlasUser.length === 0) {
     return [];
   }
@@ -16200,11 +16401,11 @@ function checkMemberOverlayDrift() {
   const results = [];
   for (const kind of ["skills", "agents"]) {
     const localRoot = path35.join(claudeDir2, `${kind}.overrides`);
-    if (!fs36.existsSync(localRoot))
+    if (!fs37.existsSync(localRoot))
       continue;
     let entries;
     try {
-      entries = fs36.readdirSync(localRoot);
+      entries = fs37.readdirSync(localRoot);
     } catch {
       continue;
     }
@@ -16212,7 +16413,7 @@ function checkMemberOverlayDrift() {
       const localFile = path35.join(localRoot, entry);
       let stat2;
       try {
-        stat2 = fs36.statSync(localFile);
+        stat2 = fs37.statSync(localFile);
       } catch {
         continue;
       }
@@ -23431,12 +23632,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve15) => {
+    return new Promise((resolve16) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve15();
+        resolve16();
       } else {
-        this._stdout.once("drain", resolve15);
+        this._stdout.once("drain", resolve16);
       }
     });
   }
@@ -25473,7 +25674,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve15) => setTimeout(resolve15, pollInterval));
+        await new Promise((resolve16) => setTimeout(resolve16, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -25490,7 +25691,7 @@ var Protocol = class {
    */
   request(request2, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve15, reject2) => {
+    return new Promise((resolve16, reject2) => {
       const earlyReject = (error2) => {
         reject2(error2);
       };
@@ -25568,7 +25769,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject2(parseResult.error);
           } else {
-            resolve15(parseResult.data);
+            resolve16(parseResult.data);
           }
         } catch (error2) {
           reject2(error2);
@@ -25829,12 +26030,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve15, reject2) => {
+    return new Promise((resolve16, reject2) => {
       if (signal.aborted) {
         reject2(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve15, interval);
+      const timeoutId = setTimeout(resolve16, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject2(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -27156,7 +27357,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve15) => setTimeout(resolve15, pollInterval));
+      await new Promise((resolve16) => setTimeout(resolve16, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -28345,7 +28546,7 @@ async function safeText(res) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve15) => setTimeout(resolve15, ms));
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
 
 // ../core/dist/auth/container.js
@@ -28491,7 +28692,7 @@ function resolveAuthServicePath() {
   return path4.join(pkgsDir, "auth-service");
 }
 function sleep2(ms) {
-  return new Promise((resolve15) => setTimeout(resolve15, ms));
+  return new Promise((resolve16) => setTimeout(resolve16, ms));
 }
 
 // ../core/dist/auth/preflight.js
@@ -29307,12 +29508,12 @@ function register3(server, _ctx, _initError) {
       registry2.close();
     }
     try {
-      const { default: fs55 } = await import("node:fs");
+      const { default: fs56 } = await import("node:fs");
       const { default: os34 } = await import("node:os");
       const { default: path56 } = await import("node:path");
       const tokenPath = path56.join(os34.homedir(), ".olam", "host-cp.token");
-      if (fs55.existsSync(tokenPath)) {
-        const token = fs55.readFileSync(tokenPath, "utf-8").trim();
+      if (fs56.existsSync(tokenPath)) {
+        const token = fs56.readFileSync(tokenPath, "utf-8").trim();
         await fetch("http://127.0.0.1:19000/api/admin/world-pr", {
           method: "POST",
           headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
@@ -29905,7 +30106,7 @@ var realDocker = {
   }
 };
 function spawnAsync(cmd, args, opts = {}) {
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     const child = spawn(cmd, [...args], {
       stdio: ["ignore", "pipe", "pipe"],
       signal: opts.signal
@@ -29919,10 +30120,10 @@ function spawnAsync(cmd, args, opts = {}) {
       stderr += chunk.toString();
     });
     child.on("error", (err) => {
-      resolve15({ exitCode: -1, stdout, stderr: stderr + err.message });
+      resolve16({ exitCode: -1, stdout, stderr: stderr + err.message });
     });
     child.on("close", (code) => {
-      resolve15({ exitCode: code ?? -1, stdout, stderr });
+      resolve16({ exitCode: code ?? -1, stdout, stderr });
     });
   });
 }
@@ -30427,7 +30628,7 @@ var stopAndRemove = async (container) => {
 
 // ../adapters/dist/docker/exec.js
 import { PassThrough } from "node:stream";
-var demuxStream = (stream) => new Promise((resolve15, reject2) => {
+var demuxStream = (stream) => new Promise((resolve16, reject2) => {
   const stdoutChunks = [];
   const stderrChunks = [];
   const stdout = new PassThrough();
@@ -30441,7 +30642,7 @@ var demuxStream = (stream) => new Promise((resolve15, reject2) => {
     stream.pipe(stdout);
   }
   stream.on("end", () => {
-    resolve15({
+    resolve16({
       stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
       stderr: Buffer.concat(stderrChunks).toString("utf-8")
     });
@@ -30814,7 +31015,7 @@ var SSHConnectionPool = class {
   // -----------------------------------------------------------------------
   async exec(host, command) {
     const client = await this.getConnection(host);
-    return new Promise((resolve15, reject2) => {
+    return new Promise((resolve16, reject2) => {
       client.exec(command, (err, stream) => {
         if (err) {
           reject2(new Error(`SSH exec failed on ${host}: ${err.message}`));
@@ -30829,7 +31030,7 @@ var SSHConnectionPool = class {
           stderr += data.toString();
         });
         stream.on("close", (code) => {
-          resolve15({
+          resolve16({
             exitCode: code ?? 0,
             stdout: stdout.trimEnd(),
             stderr: stderr.trimEnd()
@@ -30860,10 +31061,10 @@ var SSHConnectionPool = class {
       throw new Error(`No SSH configuration found for host: ${host}`);
     }
     const client = new SSHClient();
-    return new Promise((resolve15, reject2) => {
+    return new Promise((resolve16, reject2) => {
       client.on("ready", () => {
         this.connections.set(host, client);
-        resolve15(client);
+        resolve16(client);
       }).on("error", (err) => {
         this.connections.delete(host);
         reject2(new Error(`SSH connection to ${host} failed: ${err.message}`));
@@ -32049,7 +32250,7 @@ function register6(server, ctx, initError) {
             } catch {
             }
             await new Promise(
-              (resolve15) => setTimeout(resolve15, POLL_INTERVAL_MS)
+              (resolve16) => setTimeout(resolve16, POLL_INTERVAL_MS)
             );
           }
         }
@@ -33087,7 +33288,7 @@ var GoalSpecSchema = external_exports.object({
   "Optional structured completion condition; when set, the world loops between turns checking this until met or timeout"
 );
 async function defaultExecGh(args) {
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     const child = spawn2("gh", [...args], {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -33100,10 +33301,10 @@ async function defaultExecGh(args) {
       stderr += chunk.toString("utf8");
     });
     child.on("close", (code) => {
-      resolve15({ stdout, stderr, exitCode: code ?? 1 });
+      resolve16({ stdout, stderr, exitCode: code ?? 1 });
     });
     child.on("error", (err) => {
-      resolve15({
+      resolve16({
         stdout: "",
         stderr: err instanceof Error ? err.message : String(err),
         exitCode: 1
@@ -33112,7 +33313,7 @@ async function defaultExecGh(args) {
   });
 }
 async function defaultExecVitest(testNamePattern, cwd) {
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     const child = spawn2(
       "npx",
       [
@@ -33125,10 +33326,10 @@ async function defaultExecVitest(testNamePattern, cwd) {
       { cwd, stdio: ["ignore", "pipe", "pipe"] }
     );
     child.on("close", (code) => {
-      resolve15({ exitCode: code ?? 1 });
+      resolve16({ exitCode: code ?? 1 });
     });
     child.on("error", () => {
-      resolve15({ exitCode: 1 });
+      resolve16({ exitCode: 1 });
     });
   });
 }
@@ -34879,15 +35080,15 @@ ${JSON.stringify({ error: reason })}`
       unlinkSync2(udsPath);
     } catch {
     }
-    await new Promise((resolve15, reject2) => {
-      server.listen(udsPath, () => resolve15());
+    await new Promise((resolve16, reject2) => {
+      server.listen(udsPath, () => resolve16());
       server.once("error", reject2);
     });
     chmodSync5(udsPath, 384);
     port2 = 0;
   } else {
-    await new Promise((resolve15, reject2) => {
-      server.listen(opts.port ?? 0, "127.0.0.1", () => resolve15());
+    await new Promise((resolve16, reject2) => {
+      server.listen(opts.port ?? 0, "127.0.0.1", () => resolve16());
       server.once("error", reject2);
     });
     const addr = server.address();
@@ -34903,10 +35104,10 @@ ${JSON.stringify({ error: reason })}`
     } catch {
     }
     await Promise.race([
-      new Promise((resolve15, reject2) => {
-        server.close((err) => err ? reject2(err) : resolve15());
+      new Promise((resolve16, reject2) => {
+        server.close((err) => err ? reject2(err) : resolve16());
       }),
-      new Promise((resolve15) => setTimeout(resolve15, 5e3))
+      new Promise((resolve16) => setTimeout(resolve16, 5e3))
     ]);
     if (udsPath) {
       try {
@@ -35299,10 +35500,10 @@ async function acquireLaunchSlot() {
     _inFlightLaunches++;
     return releaseLaunchSlot;
   }
-  return new Promise((resolve15) => {
+  return new Promise((resolve16) => {
     _launchQueue.push(() => {
       _inFlightLaunches++;
-      resolve15(releaseLaunchSlot);
+      resolve16(releaseLaunchSlot);
     });
   });
 }
@@ -36107,12 +36308,12 @@ function openUrl(url2) {
 var HOST_CP_URL = "http://127.0.0.1:19000";
 async function readHostCpToken2() {
   try {
-    const { default: fs55 } = await import("node:fs");
+    const { default: fs56 } = await import("node:fs");
     const { default: os34 } = await import("node:os");
     const { default: path56 } = await import("node:path");
     const tp = path56.join(os34.homedir(), ".olam", "host-cp.token");
-    if (!fs55.existsSync(tp)) return { token: null };
-    return { token: fs55.readFileSync(tp, "utf-8").trim() };
+    if (!fs56.existsSync(tp)) return { token: null };
+    return { token: fs56.readFileSync(tp, "utf-8").trim() };
   } catch {
     return { token: null };
   }
@@ -36453,7 +36654,7 @@ __export(process_port_exports, {
   register: () => register23,
   resolveHostCpToken: () => resolveHostCpToken
 });
-import fs37 from "node:fs";
+import fs38 from "node:fs";
 import os22 from "node:os";
 import path36 from "node:path";
 
@@ -36501,7 +36702,7 @@ function resolveHostCpToken() {
   const envToken = process.env["OLAM_HOST_CP_TOKEN"];
   if (envToken) return envToken;
   const tokenPath = path36.join(os22.homedir(), ".olam", "host-cp.token");
-  if (fs37.existsSync(tokenPath)) return fs37.readFileSync(tokenPath, "utf-8").trim();
+  if (fs38.existsSync(tokenPath)) return fs38.readFileSync(tokenPath, "utf-8").trim();
   return null;
 }
 function tokenMissingError() {
@@ -36974,7 +37175,7 @@ __export(skills_exports, {
   register: () => register26
 });
 init_skill_sources();
-import * as fs38 from "node:fs";
+import * as fs39 from "node:fs";
 import * as path37 from "node:path";
 
 // ../skill-runtime/dist/skills/skills-sync.js
@@ -37055,13 +37256,13 @@ function listDeployed() {
   const entries = [];
   for (const bucket of ["skills", "agents", "scripts", "rules", "commands"]) {
     const bucketDir = path37.join(dir, bucket);
-    if (!fs38.existsSync(bucketDir)) continue;
-    for (const name of fs38.readdirSync(bucketDir)) {
+    if (!fs39.existsSync(bucketDir)) continue;
+    for (const name of fs39.readdirSync(bucketDir)) {
       const full = path37.join(bucketDir, name);
       try {
-        const stat2 = fs38.lstatSync(full);
+        const stat2 = fs39.lstatSync(full);
         if (!stat2.isSymbolicLink()) continue;
-        const target = fs38.readlinkSync(full);
+        const target = fs39.readlinkSync(full);
         let sourceId;
         for (const [clonePath, id] of sourcePaths.entries()) {
           if (target.startsWith(clonePath)) {
@@ -37124,7 +37325,7 @@ import * as os24 from "node:os";
 
 // ../mcp-server/src/lib/skills-index.mjs
 import { createRequire as createRequire5 } from "node:module";
-import * as fs39 from "node:fs";
+import * as fs40 from "node:fs";
 import * as path38 from "node:path";
 import * as os23 from "node:os";
 var VECTOR_DIM = 256;
@@ -37215,7 +37416,7 @@ function bufferToVector(buf) {
   return vec;
 }
 function openIndex(dbPath) {
-  if (!fs39.existsSync(dbPath)) {
+  if (!fs40.existsSync(dbPath)) {
     throw new Error(
       `skills index not found at ${dbPath}. Run \`node scripts/skills-index-build.mjs --out ${dbPath}\` first.`
     );
@@ -37549,7 +37750,7 @@ __export(kg_install_hook_exports, {
   register: () => register30
 });
 init_merge_settings();
-import * as fs40 from "node:fs";
+import * as fs41 from "node:fs";
 import * as path40 from "node:path";
 import * as os25 from "node:os";
 
@@ -37641,12 +37842,12 @@ function register30(server, _ctx, _initError) {
     const scope = params.scope === "user" ? "user" : "project";
     const filePath = settingsPathFor2(scope, params.projectPath);
     try {
-      fs40.mkdirSync(path40.dirname(filePath), { recursive: true });
+      fs41.mkdirSync(path40.dirname(filePath), { recursive: true });
       let backupPath = null;
-      if (fs40.existsSync(filePath)) {
+      if (fs41.existsSync(filePath)) {
         const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
         backupPath = `${filePath}.olam-bak.${ts}`;
-        fs40.copyFileSync(filePath, backupPath);
+        fs41.copyFileSync(filePath, backupPath);
       }
       const result = mergeHomeSettingsJson(filePath, {
         ensureHook: {
@@ -37657,7 +37858,7 @@ function register30(server, _ctx, _initError) {
       });
       if (result.status === "already-present" && backupPath) {
         try {
-          fs40.unlinkSync(backupPath);
+          fs41.unlinkSync(backupPath);
         } catch {
         }
       }
@@ -37699,7 +37900,7 @@ var kg_uninstall_hook_exports = {};
 __export(kg_uninstall_hook_exports, {
   register: () => register31
 });
-import * as fs41 from "node:fs";
+import * as fs42 from "node:fs";
 import * as path41 from "node:path";
 import * as os26 from "node:os";
 
@@ -37753,7 +37954,7 @@ function register31(server, _ctx, _initError) {
     const scope = params.scope === "user" ? "user" : "project";
     const filePath = settingsPathFor3(scope, params.projectPath);
     try {
-      if (!fs41.existsSync(filePath)) {
+      if (!fs42.existsSync(filePath)) {
         return {
           content: [
             {
@@ -37767,7 +37968,7 @@ function register31(server, _ctx, _initError) {
           ]
         };
       }
-      const raw = fs41.readFileSync(filePath, "utf-8");
+      const raw = fs42.readFileSync(filePath, "utf-8");
       const settings = raw.trim() ? JSON.parse(raw) : {};
       const preToolUse = settings.hooks?.PreToolUse;
       if (!Array.isArray(preToolUse) || preToolUse.length === 0) {
@@ -37802,7 +38003,7 @@ function register31(server, _ctx, _initError) {
       const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
       const backupPath = `${filePath}.olam-bak.${ts}`;
       try {
-        fs41.copyFileSync(filePath, backupPath);
+        fs42.copyFileSync(filePath, backupPath);
       } catch {
       }
       const next = {
@@ -37814,7 +38015,7 @@ function register31(server, _ctx, _initError) {
         if (otherStages.length === 0) delete next.hooks;
         else delete next.hooks.PreToolUse;
       }
-      fs41.writeFileSync(filePath, JSON.stringify(next, null, 2) + "\n");
+      fs42.writeFileSync(filePath, JSON.stringify(next, null, 2) + "\n");
       return {
         content: [
           {
@@ -38200,7 +38401,7 @@ ${BOUNDARY_CLOSE}`
 }
 
 // ../mcp-server/src/resources/chunks.ts
-import fs42 from "node:fs";
+import fs43 from "node:fs";
 import os27 from "node:os";
 import path42 from "node:path";
 var DEFAULT_HOST_CP_URL = "http://127.0.0.1:19000";
@@ -38219,7 +38420,7 @@ function loadBearer(bearerOpt, secretPath) {
   const envBearer = process.env.OLAM_PLAN_CHAT_BEARER?.trim();
   if (envBearer && envBearer.length > 0) return envBearer;
   try {
-    const onDisk = fs42.readFileSync(secretPath, "utf8").trim();
+    const onDisk = fs43.readFileSync(secretPath, "utf8").trim();
     return onDisk.length > 0 ? onDisk : null;
   } catch (err) {
     if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
@@ -39506,7 +39707,7 @@ init_loader();
 // ../core/dist/world/manager.js
 import * as crypto8 from "node:crypto";
 import { execSync as execSync6, spawnSync as spawnSync4 } from "node:child_process";
-import * as fs52 from "node:fs";
+import * as fs53 from "node:fs";
 import * as os32 from "node:os";
 import * as path53 from "node:path";
 
@@ -39604,7 +39805,7 @@ function resolveDevboxImage(config2, tag) {
 
 // ../core/dist/world/worktree.js
 import { execFileSync as execFileSync4 } from "node:child_process";
-import * as fs43 from "node:fs";
+import * as fs44 from "node:fs";
 import * as path43 from "node:path";
 function resolveGitDir(repo) {
   if (repo.path) {
@@ -39619,7 +39820,7 @@ async function createWorktrees(repos, worldId, workspacePath, branch) {
     const gitDir = resolveGitDir(repo);
     const branchName = branch || `olam/${worldId}`;
     try {
-      fs43.mkdirSync(path43.dirname(worktreePath), { recursive: true });
+      fs44.mkdirSync(path43.dirname(worktreePath), { recursive: true });
       execFileSync4("git", ["worktree", "add", worktreePath, "-b", branchName], {
         cwd: gitDir,
         stdio: "pipe"
@@ -39727,12 +39928,12 @@ function removeBranch(repo, branch) {
 
 // ../core/dist/world/kg-overlay.js
 import { execFileSync as execFileSync5 } from "node:child_process";
-import * as fs44 from "node:fs";
+import * as fs45 from "node:fs";
 import * as path44 from "node:path";
 
 // ../core/dist/kg/storage-paths.js
-import { homedir as homedir25 } from "node:os";
-import { join as join42, resolve as resolve10 } from "node:path";
+import { homedir as homedir26 } from "node:os";
+import { join as join43, resolve as resolve11 } from "node:path";
 
 // ../core/dist/world/workspace-name.js
 var InvalidWorkspaceNameError = class extends Error {
@@ -39753,13 +39954,13 @@ function validateWorkspaceName(name) {
 
 // ../core/dist/kg/storage-paths.js
 function olamHome2() {
-  return process.env.OLAM_HOME ?? join42(homedir25(), ".olam");
+  return process.env.OLAM_HOME ?? join43(homedir26(), ".olam");
 }
 function kgRoot() {
-  return join42(olamHome2(), "kg");
+  return join43(olamHome2(), "kg");
 }
 function worldsRoot() {
-  return join42(olamHome2(), "worlds");
+  return join43(olamHome2(), "worlds");
 }
 function assertWithinPrefix(path56, prefix, label) {
   if (!path56.startsWith(prefix + "/")) {
@@ -39769,7 +39970,7 @@ function assertWithinPrefix(path56, prefix, label) {
 function kgPristinePath(workspace) {
   validateWorkspaceName(workspace);
   const root = kgRoot();
-  const path56 = resolve10(join42(root, workspace));
+  const path56 = resolve11(join43(root, workspace));
   assertWithinPrefix(path56, root, "kgPristinePath");
   return path56;
 }
@@ -39788,9 +39989,9 @@ var KgOverlayError = class extends Error {
 };
 function ensureGitignoreEntry(worldClonePath) {
   const gitignorePath = path44.join(worldClonePath, ".gitignore");
-  if (!fs44.existsSync(gitignorePath))
+  if (!fs45.existsSync(gitignorePath))
     return "no-gitignore";
-  const content = fs44.readFileSync(gitignorePath, "utf-8");
+  const content = fs45.readFileSync(gitignorePath, "utf-8");
   const lines = content.split("\n").map((l) => l.trim());
   const recognised = /* @__PURE__ */ new Set([
     "graphify-out",
@@ -39805,24 +40006,24 @@ function ensureGitignoreEntry(worldClonePath) {
   const eol = content.includes("\r\n") ? "\r\n" : "\n";
   const needsLeadingNewline = content.length > 0 && !content.endsWith(eol);
   const block = `${needsLeadingNewline ? eol : ""}${eol}# olam-kg-service: per-world KG overlay (Phase B1)${eol}graphify-out/${eol}`;
-  fs44.appendFileSync(gitignorePath, block, "utf-8");
+  fs45.appendFileSync(gitignorePath, block, "utf-8");
   return "appended";
 }
 function createWorldOverlay(opts) {
   const pristineRoot = kgPristinePath(opts.workspace);
   const pristinePath = path44.join(pristineRoot, "graphify-out");
-  if (!fs44.existsSync(pristinePath)) {
+  if (!fs45.existsSync(pristinePath)) {
     throw new KgOverlayError(`Pristine KG for workspace ${JSON.stringify(opts.workspace)} not found at ${pristinePath}. Run \`olam kg build ${opts.workspace}\` first.`);
   }
   if (!path44.isAbsolute(opts.worldClonePath)) {
     throw new KgOverlayError(`worldClonePath must be absolute (got ${opts.worldClonePath})`);
   }
-  if (!fs44.existsSync(opts.worldClonePath)) {
+  if (!fs45.existsSync(opts.worldClonePath)) {
     throw new KgOverlayError(`worldClonePath does not exist: ${opts.worldClonePath}. Create the clone before reflinking.`);
   }
   const overlayPath = path44.join(opts.worldClonePath, "graphify-out");
-  if (fs44.existsSync(overlayPath)) {
-    fs44.rmSync(overlayPath, { recursive: true, force: true });
+  if (fs45.existsSync(overlayPath)) {
+    fs45.rmSync(overlayPath, { recursive: true, force: true });
   }
   const useReflink = process.platform === "darwin";
   let strategy;
@@ -39840,7 +40041,7 @@ function createWorldOverlay(opts) {
   } else {
     strategy = "cp-r";
   }
-  if (strategy === "cp-r" || !fs44.existsSync(overlayPath)) {
+  if (strategy === "cp-r" || !fs45.existsSync(overlayPath)) {
     try {
       execFileSync5("cp", ["-r", pristinePath, opts.worldClonePath], {
         stdio: ["ignore", "ignore", "pipe"]
@@ -39852,7 +40053,7 @@ function createWorldOverlay(opts) {
       throw new KgOverlayError(`cp -r failed: ${msg}${reflinkMsg}`);
     }
   }
-  if (!fs44.existsSync(overlayPath)) {
+  if (!fs45.existsSync(overlayPath)) {
     throw new KgOverlayError(`Overlay creation produced no ${overlayPath} after cp \u2014 filesystem returned without error?`);
   }
   const gitignoreAction = ensureGitignoreEntry(opts.worldClonePath);
@@ -39866,12 +40067,12 @@ function createWorldOverlay(opts) {
 
 // ../core/dist/world/baseline-diff.js
 import { execFileSync as execFileSync6 } from "node:child_process";
-import * as fs45 from "node:fs";
+import * as fs46 from "node:fs";
 import * as os28 from "node:os";
 import * as path45 from "node:path";
 var DEFAULT_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
-function expandHome2(p, homedir32) {
-  return p.replace(/^~(?=$|\/|\\)/, homedir32());
+function expandHome2(p, homedir33) {
+  return p.replace(/^~(?=$|\/|\\)/, homedir33());
 }
 function sanitizeRepoFilename(name) {
   const sanitized = name.replace(/[^A-Za-z0-9._-]/g, "_");
@@ -39894,10 +40095,10 @@ ${stderr}`;
 }
 function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
   const exec = deps.exec ?? ((cmd, args, opts) => execFileSync6(cmd, args, opts));
-  const homedir32 = deps.homedir ?? (() => os28.homedir());
+  const homedir33 = deps.homedir ?? (() => os28.homedir());
   const baselineDir = path45.join(workspacePath, ".olam", "baseline");
   try {
-    fs45.mkdirSync(baselineDir, { recursive: true });
+    fs46.mkdirSync(baselineDir, { recursive: true });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.warn(`[baseline-diff] mkdir ${baselineDir} failed: ${msg}; reaper will see no baseline at all`);
@@ -39910,8 +40111,8 @@ function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
       continue;
     const filename = `${sanitizeRepoFilename(repo.name)}.diff`;
     const outPath = path45.join(baselineDir, filename);
-    const repoPath = expandHome2(repo.path, homedir32);
-    if (!fs45.existsSync(repoPath)) {
+    const repoPath = expandHome2(repo.path, homedir33);
+    if (!fs46.existsSync(repoPath)) {
       writeBaselineFile(outPath, `# repo: ${repo.name}
 # (skipped: path ${repoPath} does not exist)
 `);
@@ -39978,7 +40179,7 @@ function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
 }
 function writeBaselineFile(outPath, content) {
   try {
-    fs45.writeFileSync(outPath, content);
+    fs46.writeFileSync(outPath, content);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.warn(`[baseline-diff] write to ${outPath} failed: ${msg}`);
@@ -39987,7 +40188,7 @@ function writeBaselineFile(outPath, content) {
 function stripWorktreeEdits(repos, workspacePath) {
   for (const repo of repos) {
     const worktreePath = path45.join(workspacePath, repo.name);
-    if (!fs45.existsSync(worktreePath))
+    if (!fs46.existsSync(worktreePath))
       continue;
     try {
       execFileSync6("git", ["checkout", "--", "."], {
@@ -40046,21 +40247,21 @@ function extractStderr(err) {
 }
 function carryUncommittedEdits(repos, workspacePath, deps = {}) {
   const exec = deps.exec ?? ((cmd, args, opts) => execFileSync6(cmd, args, opts));
-  const homedir32 = deps.homedir ?? (() => os28.homedir());
-  const existsSync51 = deps.existsSync ?? ((p) => fs45.existsSync(p));
-  const copyFileSync9 = deps.copyFileSync ?? ((src, dest) => fs45.copyFileSync(src, dest));
-  const mkdirSync31 = deps.mkdirSync ?? ((dirPath, opts) => {
-    fs45.mkdirSync(dirPath, opts);
+  const homedir33 = deps.homedir ?? (() => os28.homedir());
+  const existsSync53 = deps.existsSync ?? ((p) => fs46.existsSync(p));
+  const copyFileSync9 = deps.copyFileSync ?? ((src, dest) => fs46.copyFileSync(src, dest));
+  const mkdirSync32 = deps.mkdirSync ?? ((dirPath, opts) => {
+    fs46.mkdirSync(dirPath, opts);
   });
   const plans = [];
   for (const repo of repos) {
     if (!repo.path)
       continue;
-    const repoPath = expandHome2(repo.path, homedir32);
+    const repoPath = expandHome2(repo.path, homedir33);
     const worktreePath = path45.join(workspacePath, repo.name);
-    if (!existsSync51(repoPath))
+    if (!existsSync53(repoPath))
       continue;
-    if (!existsSync51(worktreePath)) {
+    if (!existsSync53(worktreePath)) {
       console.warn(`[carry] ${repo.name}: world worktree ${worktreePath} missing; skipping carry for this repo`);
       continue;
     }
@@ -40120,10 +40321,10 @@ function carryUncommittedEdits(repos, workspacePath, deps = {}) {
     for (const rel of plan.diff.untracked) {
       const src = path45.join(plan.repoPath, rel);
       const dest = path45.join(plan.worktreePath, rel);
-      if (!existsSync51(src))
+      if (!existsSync53(src))
         continue;
       try {
-        mkdirSync31(path45.dirname(dest), { recursive: true });
+        mkdirSync32(path45.dirname(dest), { recursive: true });
         copyFileSync9(src, dest);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -40149,7 +40350,7 @@ function formatBaselineSummary(result) {
 }
 
 // ../core/dist/world/context-injection.js
-import * as fs46 from "node:fs";
+import * as fs47 from "node:fs";
 import * as path46 from "node:path";
 
 // ../core/dist/world/templates/_generated.js
@@ -40161,9 +40362,9 @@ var WORLD_CLAUDE_MD = '# Olam World: {{worldName}}\n\n{{taskBlock}}\n\n## Enviro
 function injectWorldContext(opts) {
   const { world } = opts;
   const claudeDir2 = path46.join(world.workspacePath, ".claude");
-  fs46.mkdirSync(claudeDir2, { recursive: true });
+  fs47.mkdirSync(claudeDir2, { recursive: true });
   const content = WORLD_CLAUDE_MD.replace("{{worldName}}", world.name).replace("{{worldId}}", world.id).replace("{{branch}}", world.branch).replace("{{taskBlock}}", buildTaskBlock(opts)).replace("{{reposList}}", buildReposList(world)).replace("{{servicesLine}}", buildServicesLine(opts.services)).replace("{{pleriPlaneLine}}", buildPleriPlaneLine(opts.pleriPlaneUrl)).replace("{{planFileBlock}}", buildPlanFileBlock(world)).replace("{{extraContextBlock}}", buildExtraContextBlock(opts.claudeMdExtra));
-  fs46.writeFileSync(path46.join(claudeDir2, "CLAUDE.md"), content);
+  fs47.writeFileSync(path46.join(claudeDir2, "CLAUDE.md"), content);
   writeOlamDocs(world.workspacePath);
 }
 function buildTaskBlock(opts) {
@@ -40238,9 +40439,9 @@ ${extra}`;
 }
 function writeOlamDocs(workspacePath) {
   const docsDir = path46.join(workspacePath, ".olam", "docs");
-  fs46.mkdirSync(docsDir, { recursive: true });
-  fs46.writeFileSync(path46.join(docsDir, "gh-pr-create.md"), GH_PR_CREATE);
-  fs46.writeFileSync(path46.join(docsDir, "lane-orchestration.md"), LANE_ORCHESTRATION);
+  fs47.mkdirSync(docsDir, { recursive: true });
+  fs47.writeFileSync(path46.join(docsDir, "gh-pr-create.md"), GH_PR_CREATE);
+  fs47.writeFileSync(path46.join(docsDir, "lane-orchestration.md"), LANE_ORCHESTRATION);
 }
 function formatTaskSource(ctx) {
   if (ctx.source === "linear" && ctx.ticketId) {
@@ -40256,7 +40457,7 @@ function hasPlanFile(world) {
     return false;
   const plansDir = path46.join(world.workspacePath, world.repos[0], "docs", "plans");
   try {
-    return fs46.existsSync(plansDir) && fs46.readdirSync(plansDir).length > 0;
+    return fs47.existsSync(plansDir) && fs47.readdirSync(plansDir).length > 0;
   } catch {
     return false;
   }
@@ -40828,7 +41029,7 @@ init_repo_manifest();
 
 // ../core/dist/world/snapshot.js
 import * as crypto7 from "node:crypto";
-import * as fs47 from "node:fs";
+import * as fs48 from "node:fs";
 import * as os29 from "node:os";
 import * as path47 from "node:path";
 import { execFileSync as execFileSync7, spawn as spawn3 } from "node:child_process";
@@ -40843,10 +41044,10 @@ function cleanupLegacyByWorldDir(worldId) {
   const legacyDir = path47.join(snapshotsDir(), worldId);
   if (worldId === "by-workspace")
     return;
-  if (!fs47.existsSync(legacyDir))
+  if (!fs48.existsSync(legacyDir))
     return;
   try {
-    fs47.rmSync(legacyDir, { recursive: true, force: true });
+    fs48.rmSync(legacyDir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -40866,10 +41067,10 @@ function hashBuffers(entries) {
 }
 function computeGemsFingerprint(repoDir, imageDigest) {
   const lockfile = path47.join(repoDir, "Gemfile.lock");
-  if (!fs47.existsSync(lockfile))
+  if (!fs48.existsSync(lockfile))
     return null;
   const entries = [
-    { path: "Gemfile.lock", content: fs47.readFileSync(lockfile) }
+    { path: "Gemfile.lock", content: fs48.readFileSync(lockfile) }
   ];
   if (imageDigest) {
     entries.push({ path: "__image_digest__", content: Buffer.from(imageDigest, "utf-8") });
@@ -40880,9 +41081,9 @@ function computeNodeFingerprint(repoDir, imageDigest) {
   const candidates = ["yarn.lock", "pnpm-lock.yaml", "package-lock.json"];
   for (const name of candidates) {
     const lockfile = path47.join(repoDir, name);
-    if (fs47.existsSync(lockfile)) {
+    if (fs48.existsSync(lockfile)) {
       const entries = [
-        { path: name, content: fs47.readFileSync(lockfile) }
+        { path: name, content: fs48.readFileSync(lockfile) }
       ];
       if (imageDigest) {
         entries.push({ path: "__image_digest__", content: Buffer.from(imageDigest, "utf-8") });
@@ -40902,17 +41103,17 @@ function unpackTarballAtomic(srcPath, destDir) {
     };
   }
   const parent = path47.dirname(destDir);
-  fs47.mkdirSync(parent, { recursive: true });
+  fs48.mkdirSync(parent, { recursive: true });
   const tmpSuffix = `.tmp-${process.pid}-${crypto7.randomBytes(4).toString("hex")}`;
   const tmpDir = `${destDir}${tmpSuffix}`;
   try {
-    fs47.mkdirSync(tmpDir, { recursive: true });
+    fs48.mkdirSync(tmpDir, { recursive: true });
     execFileSync7("tar", ["-xzf", srcPath, "-C", tmpDir], { stdio: "pipe" });
-    fs47.renameSync(tmpDir, destDir);
+    fs48.renameSync(tmpDir, destDir);
     return { ok: true, entryCount: validation.entries.length };
   } catch (err) {
     try {
-      fs47.rmSync(tmpDir, { recursive: true, force: true });
+      fs48.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
     return {
@@ -40978,7 +41179,7 @@ function parseTarListLine(line) {
 function validateHardlinksBinary(tarPath, targetDir) {
   let raw;
   try {
-    raw = gunzipSync(fs47.readFileSync(tarPath));
+    raw = gunzipSync(fs48.readFileSync(tarPath));
   } catch {
     return null;
   }
@@ -41084,7 +41285,7 @@ function restoreSnapshotsForRepos(input) {
       const archDir = snapshotKindDirByWorkspace(input.workspace, input.arch, kind);
       const tarFilename = `${repo.name}-${input.arch}-${fingerprint}.tar.gz`;
       const tarPath = path47.join(archDir, tarFilename);
-      if (!fs47.existsSync(tarPath)) {
+      if (!fs48.existsSync(tarPath)) {
         outcomes.push({ repo: repo.name, kind, outcome: "miss", reason: "no-tarball", fingerprint });
         continue;
       }
@@ -41101,7 +41302,7 @@ function restoreSnapshotsForRepos(input) {
       }
       const targetDir = path47.join(repo.worktreeDir, targetSubpath);
       try {
-        fs47.rmSync(targetDir, { recursive: true, force: true });
+        fs48.rmSync(targetDir, { recursive: true, force: true });
       } catch {
       }
       const result = unpackTarballAtomic(tarPath, targetDir);
@@ -41114,8 +41315,8 @@ function restoreSnapshotsForRepos(input) {
           fingerprint
         });
         try {
-          fs47.rmSync(tarPath, { force: true });
-          fs47.rmSync(manifestPath(tarPath), { force: true });
+          fs48.rmSync(tarPath, { force: true });
+          fs48.rmSync(manifestPath(tarPath), { force: true });
         } catch {
         }
         continue;
@@ -41131,10 +41332,10 @@ function restoreSnapshotsForRepos(input) {
 }
 function readManifest(tarPath) {
   const mPath = manifestPath(tarPath);
-  if (!fs47.existsSync(mPath))
+  if (!fs48.existsSync(mPath))
     return null;
   try {
-    return JSON.parse(fs47.readFileSync(mPath, "utf-8"));
+    return JSON.parse(fs48.readFileSync(mPath, "utf-8"));
   } catch {
     return null;
   }
@@ -41149,17 +41350,17 @@ function isPidAlive(pid) {
   }
 }
 function evictOldSnapshotsWithFlock(maxBytes, dir = snapshotsDir()) {
-  fs47.mkdirSync(dir, { recursive: true });
+  fs48.mkdirSync(dir, { recursive: true });
   const lockPath = path47.join(dir, EVICT_LOCK_FILENAME);
   let fd;
   try {
-    fd = fs47.openSync(lockPath, fs47.constants.O_WRONLY | fs47.constants.O_CREAT | fs47.constants.O_EXCL, 384);
+    fd = fs48.openSync(lockPath, fs48.constants.O_WRONLY | fs48.constants.O_CREAT | fs48.constants.O_EXCL, 384);
   } catch (err) {
     if (err.code !== "EEXIST")
       return 0;
     let holderPid = null;
     try {
-      holderPid = parseInt(fs47.readFileSync(lockPath, "utf-8").trim(), 10);
+      holderPid = parseInt(fs48.readFileSync(lockPath, "utf-8").trim(), 10);
     } catch {
       holderPid = null;
     }
@@ -41167,23 +41368,23 @@ function evictOldSnapshotsWithFlock(maxBytes, dir = snapshotsDir()) {
       return 0;
     }
     try {
-      fs47.unlinkSync(lockPath);
-      fd = fs47.openSync(lockPath, fs47.constants.O_WRONLY | fs47.constants.O_CREAT | fs47.constants.O_EXCL, 384);
+      fs48.unlinkSync(lockPath);
+      fd = fs48.openSync(lockPath, fs48.constants.O_WRONLY | fs48.constants.O_CREAT | fs48.constants.O_EXCL, 384);
     } catch {
       return 0;
     }
   }
   try {
-    fs47.writeSync(fd, `${process.pid}
+    fs48.writeSync(fd, `${process.pid}
 `);
   } finally {
-    fs47.closeSync(fd);
+    fs48.closeSync(fd);
   }
   try {
     return evictOldSnapshots(maxBytes, dir);
   } finally {
     try {
-      fs47.unlinkSync(lockPath);
+      fs48.unlinkSync(lockPath);
     } catch {
     }
   }
@@ -41216,16 +41417,16 @@ function spawnAutoCapture(worldId, olamBin = "olam") {
   }
 }
 function evictOldSnapshots(maxBytes, dir = snapshotsDir()) {
-  if (!fs47.existsSync(dir))
+  if (!fs48.existsSync(dir))
     return 0;
   const allTars = [];
   const walk = (d) => {
-    for (const entry of fs47.readdirSync(d, { withFileTypes: true })) {
+    for (const entry of fs48.readdirSync(d, { withFileTypes: true })) {
       const full = path47.join(d, entry.name);
       if (entry.isDirectory()) {
         walk(full);
       } else if (entry.name.endsWith(".tar.gz")) {
-        const stat2 = fs47.statSync(full);
+        const stat2 = fs48.statSync(full);
         allTars.push({ path: full, size: stat2.size, mtime: stat2.mtimeMs });
       }
     }
@@ -41240,8 +41441,8 @@ function evictOldSnapshots(maxBytes, dir = snapshotsDir()) {
   for (const tar of allTars) {
     if (remaining <= maxBytes)
       break;
-    fs47.rmSync(tar.path, { force: true });
-    fs47.rmSync(manifestPath(tar.path), { force: true });
+    fs48.rmSync(tar.path, { force: true });
+    fs48.rmSync(manifestPath(tar.path), { force: true });
     freed += tar.size;
     remaining -= tar.size;
   }
@@ -41380,7 +41581,7 @@ function enrichReposWithManifests(repos, workspacePath) {
 }
 
 // ../core/dist/policies/loader.js
-import * as fs48 from "node:fs";
+import * as fs49 from "node:fs";
 import * as path49 from "node:path";
 import { parse as parseYaml5 } from "yaml";
 function parseFrontmatter2(content) {
@@ -41402,11 +41603,11 @@ function toStringArray(v) {
 }
 function loadPolicies(workspaceRoot) {
   const policiesDir = path49.join(workspaceRoot, ".olam", "policies");
-  if (!fs48.existsSync(policiesDir))
+  if (!fs49.existsSync(policiesDir))
     return [];
   let files;
   try {
-    files = fs48.readdirSync(policiesDir).filter((f) => f.endsWith(".md")).sort();
+    files = fs49.readdirSync(policiesDir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return [];
   }
@@ -41414,7 +41615,7 @@ function loadPolicies(workspaceRoot) {
   for (const file of files) {
     const filePath = path49.join(policiesDir, file);
     try {
-      const content = fs48.readFileSync(filePath, "utf8");
+      const content = fs49.readFileSync(filePath, "utf8");
       const parsed = parseFrontmatter2(content);
       if (!parsed) {
         console.warn(`[policies] skipping ${file}: no valid frontmatter block`);
@@ -41497,7 +41698,7 @@ var TaskDispatchError = class extends Error {
     this.name = "TaskDispatchError";
   }
 };
-var DEFAULT_SLEEP = (ms) => new Promise((resolve15) => setTimeout(resolve15, ms));
+var DEFAULT_SLEEP = (ms) => new Promise((resolve16) => setTimeout(resolve16, ms));
 async function probeHealth(containerName, dockerExec, budgetMs, sleep5) {
   const deadline = Date.now() + budgetMs;
   const cadenceMs = 100;
@@ -41558,7 +41759,7 @@ async function autoDispatchTask(opts) {
 }
 
 // ../core/dist/world/wiki-injection-loader.js
-import * as fs49 from "node:fs";
+import * as fs50 from "node:fs";
 import * as os30 from "node:os";
 import * as path50 from "node:path";
 var WIKI_INJECTION_FLAG = "OLAM_WIKI_INJECTION";
@@ -41578,9 +41779,9 @@ function wikiBlobPath() {
 function defaultReadBlob() {
   const p = wikiBlobPath();
   try {
-    if (!fs49.existsSync(p))
+    if (!fs50.existsSync(p))
       return null;
-    return fs49.readFileSync(p, "utf8");
+    return fs50.readFileSync(p, "utf8");
   } catch {
     return null;
   }
@@ -41619,7 +41820,7 @@ init_store();
 init_bridge();
 
 // ../core/dist/global-config/runbook-resolver.js
-import * as fs50 from "node:fs";
+import * as fs51 from "node:fs";
 import * as os31 from "node:os";
 import * as path51 from "node:path";
 function expandTilde(p) {
@@ -41636,7 +41837,7 @@ function resolveRunbookToWorldParams(runbook, repoRegistry) {
       throw new Error(`repo "${repoName}" is referenced by runbook "${runbook.name}" but is not in the registry. Run "olam repos add ${repoName} --path <path>" to register it.`);
     }
     const resolvedPath = expandTilde(entry.path);
-    if (!fs50.existsSync(resolvedPath)) {
+    if (!fs51.existsSync(resolvedPath)) {
       throw new Error(`repo "${repoName}" path "${resolvedPath}" no longer exists. Run "olam repos update ${repoName} --path <new-path>" to fix.`);
     }
   }
@@ -41652,7 +41853,7 @@ function resolveRunbookToWorldParams(runbook, repoRegistry) {
 init_port_validator();
 
 // ../core/dist/world/bootstrap-hooks.js
-import * as fs51 from "node:fs";
+import * as fs52 from "node:fs";
 import * as path52 from "node:path";
 function runFixtureCopySeeds(seeds, workspacePath) {
   if (!seeds)
@@ -41663,8 +41864,8 @@ function runFixtureCopySeeds(seeds, workspacePath) {
     const srcAbs = path52.resolve(workspacePath, seed.repo, seed.src);
     const destAbs = path52.resolve(workspacePath, seed.repo, seed.dest);
     const destDir = path52.dirname(destAbs);
-    fs51.mkdirSync(destDir, { recursive: true });
-    fs51.cpSync(srcAbs, destAbs, { recursive: true, force: true });
+    fs52.mkdirSync(destDir, { recursive: true });
+    fs52.cpSync(srcAbs, destAbs, { recursive: true, force: true });
   }
 }
 async function runSeedHooks(seeds, containerName, servicePortMap, exec) {
@@ -42451,7 +42652,7 @@ ${detail}`);
         continue;
       const sourceRoot = repo.path.replace(/^~/, os32.homedir());
       const worktreeRoot = path53.join(workspacePath, repo.name);
-      if (!fs52.existsSync(sourceRoot) || !fs52.existsSync(worktreeRoot))
+      if (!fs53.existsSync(sourceRoot) || !fs53.existsSync(worktreeRoot))
         continue;
       let copied = 0;
       for (const pattern of RUNTIME_FILE_PATTERNS) {
@@ -42459,28 +42660,28 @@ ${detail}`);
         if (pattern.includes("*")) {
           const [dir, glob] = [path53.dirname(pattern), path53.basename(pattern)];
           const sourceDir = path53.join(sourceRoot, dir);
-          if (fs52.existsSync(sourceDir)) {
+          if (fs53.existsSync(sourceDir)) {
             const ext = glob.replace(/^\*+/, "");
             try {
-              for (const entry of fs52.readdirSync(sourceDir)) {
+              for (const entry of fs53.readdirSync(sourceDir)) {
                 if (ext === "" || entry.endsWith(ext))
                   matches2.push(path53.join(dir, entry));
               }
             } catch {
             }
           }
-        } else if (fs52.existsSync(path53.join(sourceRoot, pattern))) {
+        } else if (fs53.existsSync(path53.join(sourceRoot, pattern))) {
           matches2.push(pattern);
         }
         for (const rel of matches2) {
           const src = path53.join(sourceRoot, rel);
           const dst = path53.join(worktreeRoot, rel);
           try {
-            const st = fs52.statSync(src);
+            const st = fs53.statSync(src);
             if (!st.isFile())
               continue;
-            fs52.mkdirSync(path53.dirname(dst), { recursive: true });
-            fs52.copyFileSync(src, dst);
+            fs53.mkdirSync(path53.dirname(dst), { recursive: true });
+            fs53.copyFileSync(src, dst);
             copied++;
           } catch {
           }
@@ -42666,9 +42867,9 @@ ${detail}`);
       if (opts.task)
         worldEnv.OLAM_TASK = opts.task;
       const r2CredsPath = path53.join(os32.homedir(), ".olam", "r2-credentials.json");
-      if (fs52.existsSync(r2CredsPath)) {
+      if (fs53.existsSync(r2CredsPath)) {
         try {
-          const r2Raw = fs52.readFileSync(r2CredsPath, "utf-8").trim();
+          const r2Raw = fs53.readFileSync(r2CredsPath, "utf-8").trim();
           if (r2Raw.length > 0) {
             const r2 = JSON.parse(r2Raw);
             if (typeof r2.account_id === "string")
@@ -42686,9 +42887,9 @@ ${detail}`);
         }
       }
       const keysYamlPath = path53.join(os32.homedir(), ".olam", "keys.yaml");
-      if (fs52.existsSync(keysYamlPath)) {
+      if (fs53.existsSync(keysYamlPath)) {
         try {
-          const keysRaw = fs52.readFileSync(keysYamlPath, "utf-8").trim();
+          const keysRaw = fs53.readFileSync(keysYamlPath, "utf-8").trim();
           if (keysRaw.length > 0) {
             const parsed = YAML3.parse(keysRaw);
             if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
@@ -42749,8 +42950,8 @@ ${detail}`);
         for (const { repoName, relativePath, content } of fileWrites) {
           const absPath = path53.join(workspacePath, repoName, relativePath);
           try {
-            fs52.mkdirSync(path53.dirname(absPath), { recursive: true });
-            fs52.writeFileSync(absPath, content.endsWith("\n") ? content : content + "\n", {
+            fs53.mkdirSync(path53.dirname(absPath), { recursive: true });
+            fs53.writeFileSync(absPath, content.endsWith("\n") ? content : content + "\n", {
               mode: 384
             });
             console.log(`[secrets] ${repoName}: materialised ${relativePath} (${content.length} chars, mode 0600)`);
@@ -43047,7 +43248,7 @@ ${detail}`);
           execSync6(`docker exec ${containerName} mkdir -p /home/olam/.olam/policies`, { stdio: "pipe", timeout: 1e4 });
           for (const repo of repos) {
             const policiesDir = path53.join(workspacePath, repo.name, ".olam", "policies");
-            if (fs52.existsSync(policiesDir)) {
+            if (fs53.existsSync(policiesDir)) {
               execSync6(`docker cp "${policiesDir}/." "${containerName}:/home/olam/.olam/policies/"`, { stdio: "pipe", timeout: 15e3 });
             }
           }
@@ -43157,8 +43358,8 @@ ${detail}`);
     } catch {
     }
     try {
-      fs52.rmSync(world.workspacePath, { recursive: true, force: true });
-      if (fs52.existsSync(world.workspacePath)) {
+      fs53.rmSync(world.workspacePath, { recursive: true, force: true });
+      if (fs53.existsSync(world.workspacePath)) {
         console.warn(`[WorldManager] destroyWorld(${worldId}): workspace dir ${world.workspacePath} still exists after rmSync. Run \`olam clean --apply\` to reap.`);
       }
     } catch (err) {
@@ -43267,14 +43468,14 @@ ${detail}`);
     }).filter((r) => r !== void 0);
   }
   transportPlanFile(planFilePath, workspacePath, repoNames) {
-    const planContent = fs52.readFileSync(planFilePath, "utf-8");
+    const planContent = fs53.readFileSync(planFilePath, "utf-8");
     const planFileName = path53.basename(planFilePath);
     const targetRepo = repoNames[0];
     if (!targetRepo)
       return;
     const plansDir = path53.join(workspacePath, targetRepo, "docs", "plans");
-    fs52.mkdirSync(plansDir, { recursive: true });
-    fs52.writeFileSync(path53.join(plansDir, planFileName), planContent);
+    fs53.mkdirSync(plansDir, { recursive: true });
+    fs53.writeFileSync(path53.join(plansDir, planFileName), planContent);
   }
   resolveServices(repos) {
     const services = [];
@@ -43738,9 +43939,9 @@ import * as http2 from "node:http";
 
 // ../core/dist/dashboard/server.js
 import * as http from "node:http";
-import * as fs53 from "node:fs";
+import * as fs54 from "node:fs";
 import * as path54 from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // ../core/dist/dashboard/serialize.js
 function serializeTokenUsage(usage) {
@@ -44074,7 +44275,7 @@ function notFound(res) {
 }
 function openThoughtStore(workspacePath) {
   const dbPath = getWorldDbPath(workspacePath);
-  if (!fs53.existsSync(dbPath))
+  if (!fs54.existsSync(dbPath))
     return null;
   return new ThoughtLocalStore(dbPath);
 }
@@ -44245,13 +44446,13 @@ function findSessionInWorld(registry2, sessionId) {
 }
 function createDashboardServer(opts) {
   const { port: port2, registry: registry2 } = opts;
-  const thisDir = path54.dirname(fileURLToPath3(import.meta.url));
+  const thisDir = path54.dirname(fileURLToPath4(import.meta.url));
   const defaultPublicDir = path54.resolve(thisDir, "../../../control-plane/public");
   const publicDir = opts.publicDir ?? defaultPublicDir;
-  let hasPublicDir = fs53.existsSync(publicDir);
+  let hasPublicDir = fs54.existsSync(publicDir);
   const server = http.createServer((req, res) => {
     if (!hasPublicDir) {
-      hasPublicDir = fs53.existsSync(publicDir);
+      hasPublicDir = fs54.existsSync(publicDir);
     }
     const host = req.headers.host ?? `localhost:${port2}`;
     const url2 = new URL(req.url ?? "/", `http://${host}`);
@@ -44530,17 +44731,17 @@ function createDashboardServer(opts) {
       notFound(res);
       return;
     }
-    if (fs53.existsSync(filePath) && fs53.statSync(filePath).isFile()) {
+    if (fs54.existsSync(filePath) && fs54.statSync(filePath).isFile()) {
       const ext = path54.extname(filePath);
       const contentType = MIME[ext] ?? "application/octet-stream";
       res.writeHead(200, { "Content-Type": contentType });
-      fs53.createReadStream(filePath).pipe(res);
+      fs54.createReadStream(filePath).pipe(res);
       return;
     }
     filePath = path54.join(publicDir, "index.html");
-    if (fs53.existsSync(filePath)) {
+    if (fs54.existsSync(filePath)) {
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-      fs53.createReadStream(filePath).pipe(res);
+      fs54.createReadStream(filePath).pipe(res);
       return;
     }
     notFound(res);
@@ -44550,17 +44751,17 @@ function createDashboardServer(opts) {
 }
 
 // ../core/dist/dashboard/state.js
-import * as fs54 from "node:fs";
+import * as fs55 from "node:fs";
 import * as os33 from "node:os";
 import * as path55 from "node:path";
 var STATE_PATH = path55.join(os33.homedir(), ".olam", "dashboard.json");
 function saveDashboardState(state) {
-  fs54.mkdirSync(path55.dirname(STATE_PATH), { recursive: true });
-  fs54.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2));
+  fs55.mkdirSync(path55.dirname(STATE_PATH), { recursive: true });
+  fs55.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2));
 }
 function loadDashboardState() {
   try {
-    const raw = fs54.readFileSync(STATE_PATH, "utf-8");
+    const raw = fs55.readFileSync(STATE_PATH, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -44568,7 +44769,7 @@ function loadDashboardState() {
 }
 function clearDashboardState() {
   try {
-    fs54.unlinkSync(STATE_PATH);
+    fs55.unlinkSync(STATE_PATH);
   } catch {
   }
 }
@@ -44597,7 +44798,7 @@ function isCloudflaredAvailable() {
   }
 }
 function startTunnel(port2) {
-  return new Promise((resolve15, reject2) => {
+  return new Promise((resolve16, reject2) => {
     const child = spawn4("cloudflared", ["tunnel", "--url", `http://localhost:${port2}`], {
       stdio: ["ignore", "pipe", "pipe"],
       detached: false
@@ -44619,7 +44820,7 @@ function startTunnel(port2) {
       if (match) {
         resolved = true;
         clearTimeout(timeout);
-        resolve15(match[0]);
+        resolve16(match[0]);
       }
     }
     child.stdout?.on("data", scan);
@@ -44687,8 +44888,8 @@ var DashboardManager = class {
       }
       throw err;
     }
-    await new Promise((resolve15, reject2) => {
-      this.server.on("listening", resolve15);
+    await new Promise((resolve16, reject2) => {
+      this.server.on("listening", resolve16);
       this.server.on("error", reject2);
     });
     this.info = { localUrl: `http://localhost:${port2}` };
@@ -44734,8 +44935,8 @@ var DashboardManager = class {
   async stop() {
     stopTunnel();
     if (this.server) {
-      await new Promise((resolve15) => {
-        this.server.close(() => resolve15());
+      await new Promise((resolve16) => {
+        this.server.close(() => resolve16());
       });
       this.server = null;
     }
@@ -44848,8 +45049,8 @@ var PleriClient = class {
 };
 
 // ../mcp-server/src/env-loader.ts
-import { readFileSync as readFileSync41, existsSync as existsSync50, statSync as statSync14 } from "node:fs";
-import { join as join54, dirname as dirname29, resolve as resolve14 } from "node:path";
+import { readFileSync as readFileSync43, existsSync as existsSync52, statSync as statSync14 } from "node:fs";
+import { join as join55, dirname as dirname30, resolve as resolve15 } from "node:path";
 var PROJECT_MARKERS = [
   ".olam/config.yaml",
   ".olam/config.yml",
@@ -44857,30 +45058,30 @@ var PROJECT_MARKERS = [
   "olam.yml"
 ];
 function findProjectRoot2(startDir) {
-  let dir = resolve14(startDir);
-  const root = resolve14("/");
+  let dir = resolve15(startDir);
+  const root = resolve15("/");
   while (true) {
     for (const marker of PROJECT_MARKERS) {
-      if (existsSync50(join54(dir, marker))) return dir;
+      if (existsSync52(join55(dir, marker))) return dir;
     }
-    const pkg = join54(dir, "package.json");
-    if (existsSync50(pkg)) {
+    const pkg = join55(dir, "package.json");
+    if (existsSync52(pkg)) {
       try {
-        const json = JSON.parse(readFileSync41(pkg, "utf8"));
+        const json = JSON.parse(readFileSync43(pkg, "utf8"));
         const isOlamWorkspace = typeof json.name === "string" && json.name.startsWith("@olam/");
         const hasOlamDep = json.dependencies && Object.keys(json.dependencies).some((k) => k.startsWith("@olam/")) || json.devDependencies && Object.keys(json.devDependencies).some((k) => k.startsWith("@olam/"));
         if (isOlamWorkspace || hasOlamDep) return dir;
       } catch {
       }
     }
-    const parent = dirname29(dir);
+    const parent = dirname30(dir);
     if (parent === dir || parent === root) return null;
     dir = parent;
   }
 }
 function parseEnvFile(path56) {
   const out = {};
-  const raw = readFileSync41(path56, "utf8");
+  const raw = readFileSync43(path56, "utf8");
   for (const line of raw.split(/\r?\n/)) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#")) continue;
@@ -44903,8 +45104,8 @@ function loadProjectEnv(startDir = process.cwd()) {
   const filesRead = [];
   const merged = {};
   for (const name of [".env", ".env.local"]) {
-    const p = join54(root, name);
-    if (existsSync50(p) && statSync14(p).isFile()) {
+    const p = join55(root, name);
+    if (existsSync52(p) && statSync14(p).isFile()) {
       Object.assign(merged, parseEnvFile(p));
       filesRead.push(p);
     }