@pleri/olam-cli 0.1.199 → 0.1.201

package/dist/index.js

@@ -5568,7 +5568,7 @@ async function safeText(res) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve30) => setTimeout(resolve30, ms));
+  return new Promise((resolve31) => setTimeout(resolve31, ms));
 }
 var DEFAULT_BASE_URL, DEFAULT_TIMEOUT_MS, RETRY_COUNT, RETRY_BACKOFF_MS, AuthClient;
 var init_client = __esm({
@@ -5721,7 +5721,7 @@ function resolveAuthServicePath() {
   return path10.join(pkgsDir, "auth-service");
 }
 function sleep2(ms) {
-  return new Promise((resolve30) => setTimeout(resolve30, ms));
+  return new Promise((resolve31) => setTimeout(resolve31, ms));
 }
 var DEFAULT_PORT, DEFAULT_VOLUME, DEFAULT_CONTAINER, DEFAULT_IMAGE, AuthContainerController;
 var init_container = __esm({
@@ -6032,7 +6032,7 @@ var init_network = __esm({
 // ../adapters/dist/docker/pull.js
 import { spawn } from "node:child_process";
 function spawnAsync(cmd, args, opts = {}) {
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     const child = spawn(cmd, [...args], {
       stdio: ["ignore", "pipe", "pipe"],
       signal: opts.signal
@@ -6046,10 +6046,10 @@ function spawnAsync(cmd, args, opts = {}) {
       stderr += chunk.toString();
     });
     child.on("error", (err) => {
-      resolve30({ exitCode: -1, stdout, stderr: stderr + err.message });
+      resolve31({ exitCode: -1, stdout, stderr: stderr + err.message });
     });
     child.on("close", (code) => {
-      resolve30({ exitCode: code ?? -1, stdout, stderr });
+      resolve31({ exitCode: code ?? -1, stdout, stderr });
     });
   });
 }
@@ -6614,7 +6614,7 @@ var demuxStream, execInContainer;
 var init_exec = __esm({
   "../adapters/dist/docker/exec.js"() {
     "use strict";
-    demuxStream = (stream) => new Promise((resolve30, reject) => {
+    demuxStream = (stream) => new Promise((resolve31, reject) => {
       const stdoutChunks = [];
       const stderrChunks = [];
       const stdout = new PassThrough();
@@ -6628,7 +6628,7 @@ var init_exec = __esm({
         stream.pipe(stdout);
       }
       stream.on("end", () => {
-        resolve30({
+        resolve31({
           stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
           stderr: Buffer.concat(stderrChunks).toString("utf-8")
         });
@@ -7088,7 +7088,7 @@ var init_connection = __esm({
       // -----------------------------------------------------------------------
       async exec(host, command) {
         const client = await this.getConnection(host);
-        return new Promise((resolve30, reject) => {
+        return new Promise((resolve31, reject) => {
           client.exec(command, (err, stream) => {
             if (err) {
               reject(new Error(`SSH exec failed on ${host}: ${err.message}`));
@@ -7103,7 +7103,7 @@ var init_connection = __esm({
               stderr += data.toString();
             });
             stream.on("close", (code) => {
-              resolve30({
+              resolve31({
                 exitCode: code ?? 0,
                 stdout: stdout.trimEnd(),
                 stderr: stderr.trimEnd()
@@ -7134,10 +7134,10 @@ var init_connection = __esm({
           throw new Error(`No SSH configuration found for host: ${host}`);
         }
         const client = new SSHClient();
-        return new Promise((resolve30, reject) => {
+        return new Promise((resolve31, reject) => {
           client.on("ready", () => {
             this.connections.set(host, client);
-            resolve30(client);
+            resolve31(client);
           }).on("error", (err) => {
             this.connections.delete(host);
             reject(new Error(`SSH connection to ${host} failed: ${err.message}`));
@@ -9539,8 +9539,8 @@ import { execFileSync as execFileSync4 } from "node:child_process";
 import * as fs17 from "node:fs";
 import * as os11 from "node:os";
 import * as path19 from "node:path";
-function expandHome2(p, homedir76) {
-  return p.replace(/^~(?=$|\/|\\)/, homedir76());
+function expandHome2(p, homedir77) {
+  return p.replace(/^~(?=$|\/|\\)/, homedir77());
 }
 function sanitizeRepoFilename(name) {
   const sanitized = name.replace(/[^A-Za-z0-9._-]/g, "_");
@@ -9563,7 +9563,7 @@ ${stderr}`;
 }
 function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
   const exec = deps.exec ?? ((cmd, args, opts) => execFileSync4(cmd, args, opts));
-  const homedir76 = deps.homedir ?? (() => os11.homedir());
+  const homedir77 = deps.homedir ?? (() => os11.homedir());
   const baselineDir = path19.join(workspacePath, ".olam", "baseline");
   try {
     fs17.mkdirSync(baselineDir, { recursive: true });
@@ -9579,7 +9579,7 @@ function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
       continue;
     const filename = `${sanitizeRepoFilename(repo.name)}.diff`;
     const outPath = path19.join(baselineDir, filename);
-    const repoPath = expandHome2(repo.path, homedir76);
+    const repoPath = expandHome2(repo.path, homedir77);
     if (!fs17.existsSync(repoPath)) {
       writeBaselineFile(outPath, `# repo: ${repo.name}
 # (skipped: path ${repoPath} does not exist)
@@ -9699,21 +9699,21 @@ function extractStderr(err) {
 }
 function carryUncommittedEdits(repos, workspacePath, deps = {}) {
   const exec = deps.exec ?? ((cmd, args, opts) => execFileSync4(cmd, args, opts));
-  const homedir76 = deps.homedir ?? (() => os11.homedir());
-  const existsSync120 = deps.existsSync ?? ((p) => fs17.existsSync(p));
+  const homedir77 = deps.homedir ?? (() => os11.homedir());
+  const existsSync122 = deps.existsSync ?? ((p) => fs17.existsSync(p));
   const copyFileSync17 = deps.copyFileSync ?? ((src, dest) => fs17.copyFileSync(src, dest));
-  const mkdirSync72 = deps.mkdirSync ?? ((dirPath, opts) => {
+  const mkdirSync73 = deps.mkdirSync ?? ((dirPath, opts) => {
     fs17.mkdirSync(dirPath, opts);
   });
   const plans = [];
   for (const repo of repos) {
     if (!repo.path)
       continue;
-    const repoPath = expandHome2(repo.path, homedir76);
+    const repoPath = expandHome2(repo.path, homedir77);
     const worktreePath = path19.join(workspacePath, repo.name);
-    if (!existsSync120(repoPath))
+    if (!existsSync122(repoPath))
       continue;
-    if (!existsSync120(worktreePath)) {
+    if (!existsSync122(worktreePath)) {
       console.warn(`[carry] ${repo.name}: world worktree ${worktreePath} missing; skipping carry for this repo`);
       continue;
     }
@@ -9773,10 +9773,10 @@ function carryUncommittedEdits(repos, workspacePath, deps = {}) {
     for (const rel of plan.diff.untracked) {
       const src = path19.join(plan.repoPath, rel);
       const dest = path19.join(plan.worktreePath, rel);
-      if (!existsSync120(src))
+      if (!existsSync122(src))
         continue;
       try {
-        mkdirSync72(path19.dirname(dest), { recursive: true });
+        mkdirSync73(path19.dirname(dest), { recursive: true });
         copyFileSync17(src, dest);
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -11425,7 +11425,7 @@ var init_auto_dispatch_task = __esm({
         this.name = "TaskDispatchError";
       }
     };
-    DEFAULT_SLEEP = (ms) => new Promise((resolve30) => setTimeout(resolve30, ms));
+    DEFAULT_SLEEP = (ms) => new Promise((resolve31) => setTimeout(resolve31, ms));
   }
 });
 
@@ -11660,7 +11660,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([]),
@@ -15417,7 +15417,7 @@ function isCloudflaredAvailable() {
   }
 }
 function startTunnel(port2) {
-  return new Promise((resolve30, reject) => {
+  return new Promise((resolve31, reject) => {
     const child = spawn3("cloudflared", ["tunnel", "--url", `http://localhost:${port2}`], {
       stdio: ["ignore", "pipe", "pipe"],
       detached: false
@@ -15439,7 +15439,7 @@ function startTunnel(port2) {
       if (match2) {
         resolved = true;
         clearTimeout(timeout);
-        resolve30(match2[0]);
+        resolve31(match2[0]);
       }
     }
     child.stdout?.on("data", scan);
@@ -15526,8 +15526,8 @@ var init_dashboard = __esm({
           }
           throw err;
         }
-        await new Promise((resolve30, reject) => {
-          this.server.on("listening", resolve30);
+        await new Promise((resolve31, reject) => {
+          this.server.on("listening", resolve31);
           this.server.on("error", reject);
         });
         this.info = { localUrl: `http://localhost:${port2}` };
@@ -15573,8 +15573,8 @@ var init_dashboard = __esm({
       async stop() {
         stopTunnel();
         if (this.server) {
-          await new Promise((resolve30) => {
-            this.server.close(() => resolve30());
+          await new Promise((resolve31) => {
+            this.server.close(() => resolve31());
           });
           this.server = null;
         }
@@ -15903,8 +15903,8 @@ async function findHostCpContainer() {
   const docker3 = new Dockerode2(resolveDockerHostOptions());
   let timer = null;
   const listing = docker3.listContainers({ all: true }).then((cs) => cs);
-  const timeout = new Promise((resolve30) => {
-    timer = setTimeout(() => resolve30(null), DOCKER_PROBE_TIMEOUT_MS);
+  const timeout = new Promise((resolve31) => {
+    timer = setTimeout(() => resolve31(null), DOCKER_PROBE_TIMEOUT_MS);
   });
   let containers;
   try {
@@ -16688,7 +16688,7 @@ async function ensureOlamPostgresSingleton(options = {}) {
   };
 }
 function sleep3(ms) {
-  return new Promise((resolve30) => setTimeout(resolve30, ms));
+  return new Promise((resolve31) => setTimeout(resolve31, ms));
 }
 var DEFAULT_POSTGRES_NETWORK, DEFAULT_POSTGRES_CONTAINER, DEFAULT_POSTGRES_HOST_PORT, DEFAULT_POSTGRES_IMAGE, DEFAULT_POSTGRES_USER, DEFAULT_POSTGRES_PASSWORD, DEFAULT_POSTGRES_DB, DEFAULT_POSTGRES_READY_TIMEOUT_MS;
 var init_postgres_init_helpers = __esm({
@@ -18399,17 +18399,143 @@ var init_memory_classify = __esm({
   }
 });
 
+// ../core/dist/meta-hooks/model-router.js
+import * as fs69 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 existsSync77, mkdirSync as mkdirSync45, readFileSync as readFileSync66, writeFileSync as writeFileSync41 } from "node:fs";
+import { homedir as homedir43 } from "node:os";
+import { dirname as dirname39, join as join75, resolve as resolve20 } from "node:path";
+import { fileURLToPath as fileURLToPath8 } from "node:url";
+function resolveModelRouterSourcePath() {
+  const here3 = dirname39(fileURLToPath8(import.meta.url));
+  const candidates2 = [
+    // (1) in-repo tsc dist: core/dist/meta-hooks → ../../../cli/hooks
+    resolve20(here3, "..", "..", "..", "cli", "hooks", MODEL_ROUTER_SCRIPT_BASENAME),
+    // (1b) in-repo src (tsx / vitest): core/src/meta-hooks → ../../../cli/hooks
+    resolve20(here3, "..", "..", "..", "cli", "hooks", MODEL_ROUTER_SCRIPT_BASENAME),
+    // (2) bundled CLI: dist/<bundle> → ../hooks (hooks is sibling of dist)
+    resolve20(here3, "..", "hooks", MODEL_ROUTER_SCRIPT_BASENAME),
+    resolve20(here3, "..", "..", "hooks", MODEL_ROUTER_SCRIPT_BASENAME)
+  ];
+  for (const candidate of candidates2) {
+    if (existsSync77(candidate))
+      return candidate;
+  }
+  return candidates2[0];
+}
+function deployModelRouterScript(opts = {}) {
+  const targetDir = opts.targetDir ?? join75(homedir43(), ".claude", "hooks");
+  const targetPath = join75(targetDir, MODEL_ROUTER_SCRIPT_BASENAME);
+  const sourcePath = opts.sourcePath ?? resolveModelRouterSourcePath();
+  if (!existsSync77(sourcePath)) {
+    return { basename: MODEL_ROUTER_SCRIPT_BASENAME, action: "source-missing", targetPath };
+  }
+  const newContent = readFileSync66(sourcePath, "utf8");
+  if (existsSync77(targetPath)) {
+    const existing = readFileSync66(targetPath, "utf8");
+    if (existing === newContent) {
+      return { basename: MODEL_ROUTER_SCRIPT_BASENAME, action: "unchanged", targetPath };
+    }
+  }
+  if (opts.dryRun !== true) {
+    mkdirSync45(dirname39(targetPath), { recursive: true });
+    writeFileSync41(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 fs69 from "node:fs";
+import * as fs70 from "node:fs";
 import * as os39 from "node:os";
 import * as path68 from "node:path";
 function claudeSettingsPath() {
@@ -18478,28 +18604,28 @@ function tagOlam(entry) {
   return { ...entry, [OLAM_SKILLS_MARKER]: true };
 }
 function readJson(file) {
-  return JSON.parse(fs69.readFileSync(file, "utf-8"));
+  return JSON.parse(fs70.readFileSync(file, "utf-8"));
 }
 function rotateBackups(backupDir) {
-  if (!fs69.existsSync(backupDir))
+  if (!fs70.existsSync(backupDir))
     return;
-  const files = fs69.readdirSync(backupDir).filter((f) => f.endsWith(".json")).map((f) => ({ name: f, full: path68.join(backupDir, f), mtime: fs69.statSync(path68.join(backupDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
+  const files = fs70.readdirSync(backupDir).filter((f) => f.endsWith(".json")).map((f) => ({ name: f, full: path68.join(backupDir, f), mtime: fs70.statSync(path68.join(backupDir, f)).mtimeMs })).sort((a, b) => b.mtime - a.mtime);
   for (const f of files.slice(BACKUP_RETENTION)) {
     try {
-      fs69.unlinkSync(f.full);
+      fs70.unlinkSync(f.full);
     } catch {
     }
   }
 }
 function backupSettings() {
   const src = claudeSettingsPath();
-  if (!fs69.existsSync(src))
+  if (!fs70.existsSync(src))
     return void 0;
   const dir = settingsBackupDir();
-  fs69.mkdirSync(dir, { recursive: true });
+  fs70.mkdirSync(dir, { recursive: true });
   const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const dest = path68.join(dir, `settings-${stamp}.json`);
-  fs69.copyFileSync(src, dest);
+  fs70.copyFileSync(src, dest);
   rotateBackups(dir);
   return dest;
 }
@@ -18507,7 +18633,7 @@ function mergeSettings(input2) {
   const settingsPath = claudeSettingsPath();
   const backupPath = backupSettings();
   let base = {};
-  if (fs69.existsSync(settingsPath)) {
+  if (fs70.existsSync(settingsPath)) {
     try {
       base = readJson(settingsPath);
     } catch {
@@ -18575,10 +18701,10 @@ function mergeSettings(input2) {
       ...input2.permissionFiles.length > 0 ? { allow: [...permSet] } : {}
     }
   };
-  fs69.mkdirSync(path68.dirname(settingsPath), { recursive: true });
+  fs70.mkdirSync(path68.dirname(settingsPath), { recursive: true });
   const tmp = `${settingsPath}.tmp-${process.pid}`;
-  fs69.writeFileSync(tmp, JSON.stringify(next, null, 2) + "\n", { mode: 420 });
-  fs69.renameSync(tmp, settingsPath);
+  fs70.writeFileSync(tmp, JSON.stringify(next, null, 2) + "\n", { mode: 420 });
+  fs70.renameSync(tmp, settingsPath);
   return { backupPath, hooksAdded, permissionsCount: permSet.size, dualWriteDeduped, dualWriteDroppedCommands };
 }
 var OLAM_SKILLS_MARKER, BACKUP_RETENTION, DUAL_WRITE_DEDUP_RULES;
@@ -18635,7 +18761,7 @@ var init_schema5 = __esm({
 
 // ../core/dist/skill-sync/per-project-override.js
 import { execFileSync as execFileSync16 } from "node:child_process";
-import * as fs70 from "node:fs";
+import * as fs71 from "node:fs";
 import * as path69 from "node:path";
 import { parse as parseYaml6 } from "yaml";
 function findProjectOverride(startDir) {
@@ -18643,8 +18769,8 @@ function findProjectOverride(startDir) {
   const root = path69.parse(dir).root;
   while (true) {
     const candidate = path69.join(dir, PROJECT_OVERRIDE_RELATIVE_PATH);
-    if (fs70.existsSync(candidate) && fs70.statSync(candidate).isFile()) {
-      const raw = fs70.readFileSync(candidate, "utf-8");
+    if (fs71.existsSync(candidate) && fs71.statSync(candidate).isFile()) {
+      const raw = fs71.readFileSync(candidate, "utf-8");
       let parsed;
       try {
         parsed = parseYaml6(raw);
@@ -18703,7 +18829,7 @@ var init_per_project_override = __esm({
 });
 
 // ../core/dist/lib/file-lock.js
-import * as fs71 from "node:fs";
+import * as fs72 from "node:fs";
 import * as os40 from "node:os";
 import * as path70 from "node:path";
 function defaultIsPidAlive(pid) {
@@ -18716,11 +18842,11 @@ function defaultIsPidAlive(pid) {
   }
 }
 function sleep7(ms) {
-  return new Promise((resolve30) => setTimeout(resolve30, ms));
+  return new Promise((resolve31) => setTimeout(resolve31, ms));
 }
 function readLockMeta(lockPath) {
   try {
-    const raw = fs71.readFileSync(lockPath, "utf-8");
+    const raw = fs72.readFileSync(lockPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.pid === "number" && typeof parsed?.hostname === "string" && typeof parsed?.timestamp === "number") {
       return parsed;
@@ -18739,12 +18865,12 @@ function isLockStale(meta, opts) {
 }
 function tryAcquireOnce(lockPath, meta, opts) {
   try {
-    fs71.mkdirSync(path70.dirname(lockPath), { recursive: true });
-    const fd = fs71.openSync(lockPath, "wx", 384);
+    fs72.mkdirSync(path70.dirname(lockPath), { recursive: true });
+    const fd = fs72.openSync(lockPath, "wx", 384);
     try {
-      fs71.writeSync(fd, JSON.stringify(meta));
+      fs72.writeSync(fd, JSON.stringify(meta));
     } finally {
-      fs71.closeSync(fd);
+      fs72.closeSync(fd);
     }
     return true;
   } catch (err) {
@@ -18754,14 +18880,14 @@ function tryAcquireOnce(lockPath, meta, opts) {
     const existing = readLockMeta(lockPath);
     if (existing === void 0) {
       try {
-        fs71.unlinkSync(lockPath);
+        fs72.unlinkSync(lockPath);
       } catch {
       }
       return tryAcquireOnce(lockPath, meta, opts);
     }
     if (isLockStale(existing, opts)) {
       try {
-        fs71.unlinkSync(lockPath);
+        fs72.unlinkSync(lockPath);
       } catch {
       }
       return tryAcquireOnce(lockPath, meta, opts);
@@ -18791,7 +18917,7 @@ async function acquireFileLock(lockDir, options = {}) {
         lockPath,
         release: () => {
           try {
-            fs71.unlinkSync(lockPath);
+            fs72.unlinkSync(lockPath);
           } catch {
           }
         }
@@ -18831,13 +18957,13 @@ var init_file_lock = __esm({
 });
 
 // ../core/dist/lib/min-version-filter.js
-import { existsSync as existsSync78, readFileSync as readFileSync68 } from "node:fs";
+import { existsSync as existsSync80, readFileSync as readFileSync70 } from "node:fs";
 function readOlamMinVersion(filepath) {
-  if (!existsSync78(filepath))
+  if (!existsSync80(filepath))
     return void 0;
   let text;
   try {
-    text = readFileSync68(filepath, "utf8");
+    text = readFileSync70(filepath, "utf8");
   } catch {
     return void 0;
   }
@@ -18895,11 +19021,11 @@ var init_min_version_filter = __esm({
 });
 
 // ../core/dist/skill-sync/overlay-scan.js
-import * as fs72 from "node:fs";
+import * as fs73 from "node:fs";
 import * as path71 from "node:path";
 function scanOverlayReferences(overlayRoot, basenames, caps = DEFAULT_CAPS) {
   const result = /* @__PURE__ */ new Map();
-  if (!fs72.existsSync(overlayRoot)) {
+  if (!fs73.existsSync(overlayRoot)) {
     return result;
   }
   if (basenames.length === 0) {
@@ -18908,13 +19034,13 @@ function scanOverlayReferences(overlayRoot, basenames, caps = DEFAULT_CAPS) {
   const mdFiles = [];
   let overlayRootReal;
   try {
-    overlayRootReal = fs72.realpathSync(overlayRoot);
+    overlayRootReal = fs73.realpathSync(overlayRoot);
   } catch {
     return result;
   }
   for (const subdir of OVERRIDE_SUBDIRS) {
     const dir = path71.join(overlayRoot, subdir);
-    if (!fs72.existsSync(dir))
+    if (!fs73.existsSync(dir))
       continue;
     walkMarkdown(dir, mdFiles, caps.maxFiles);
   }
@@ -18922,7 +19048,7 @@ function scanOverlayReferences(overlayRoot, basenames, caps = DEFAULT_CAPS) {
   for (const filepath of mdFiles) {
     let realFile;
     try {
-      realFile = fs72.realpathSync(filepath);
+      realFile = fs73.realpathSync(filepath);
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT" || code === "EACCES")
@@ -18935,12 +19061,12 @@ function scanOverlayReferences(overlayRoot, basenames, caps = DEFAULT_CAPS) {
     }
     let content;
     try {
-      const stat = fs72.statSync(filepath);
+      const stat = fs73.statSync(filepath);
       totalBytes += stat.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 = fs72.readFileSync(filepath, "utf8");
+      content = fs73.readFileSync(filepath, "utf8");
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT" || code === "EACCES") {
@@ -18962,7 +19088,7 @@ function scanOverlayReferences(overlayRoot, basenames, caps = DEFAULT_CAPS) {
 function walkMarkdown(dir, out, cap) {
   let entries;
   try {
-    entries = fs72.readdirSync(dir, { withFileTypes: true });
+    entries = fs73.readdirSync(dir, { withFileTypes: true });
   } catch (err) {
     if (err.code === "ENOENT")
       return;
@@ -18997,7 +19123,7 @@ var init_overlay_scan = __esm({
 });
 
 // ../core/dist/skill-sync/settings-json-lock.js
-import * as fs73 from "node:fs";
+import * as fs74 from "node:fs";
 import * as os41 from "node:os";
 import * as path72 from "node:path";
 function defaultSettingsJsonLockPath() {
@@ -19014,11 +19140,11 @@ function defaultIsPidAlive2(pid) {
   }
 }
 function sleep8(ms) {
-  return new Promise((resolve30) => setTimeout(resolve30, ms));
+  return new Promise((resolve31) => setTimeout(resolve31, ms));
 }
 function readLockMeta2(lockPath) {
   try {
-    const raw = fs73.readFileSync(lockPath, "utf-8");
+    const raw = fs74.readFileSync(lockPath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed?.pid === "number" && typeof parsed?.hostname === "string" && typeof parsed?.timestamp === "number") {
       return parsed;
@@ -19041,12 +19167,12 @@ function isLockStale2(meta, opts) {
 function tryAcquireOnce2(lockPath, meta, opts) {
   for (let attempt = 0; attempt <= MAX_STEAL_ATTEMPTS; attempt += 1) {
     try {
-      fs73.mkdirSync(path72.dirname(lockPath), { recursive: true });
-      const fd = fs73.openSync(lockPath, "wx", 384);
+      fs74.mkdirSync(path72.dirname(lockPath), { recursive: true });
+      const fd = fs74.openSync(lockPath, "wx", 384);
       try {
-        fs73.writeSync(fd, JSON.stringify(meta));
+        fs74.writeSync(fd, JSON.stringify(meta));
       } finally {
-        fs73.closeSync(fd);
+        fs74.closeSync(fd);
       }
       return true;
     } catch (err) {
@@ -19064,9 +19190,9 @@ function tryAcquireOnce2(lockPath, meta, opts) {
     }
     const victimPath = `${lockPath}.victim-${process.pid}-${attempt}-${Date.now()}`;
     try {
-      fs73.renameSync(lockPath, victimPath);
+      fs74.renameSync(lockPath, victimPath);
       try {
-        fs73.unlinkSync(victimPath);
+        fs74.unlinkSync(victimPath);
       } catch {
       }
     } catch (err) {
@@ -19098,7 +19224,7 @@ async function acquireSettingsJsonLock(options = {}) {
         lockPath,
         release: () => {
           try {
-            fs73.unlinkSync(lockPath);
+            fs74.unlinkSync(lockPath);
           } catch {
           }
         }
@@ -19201,7 +19327,7 @@ var init_services_status = __esm({
 
 // ../core/dist/skill-sources/meta-hooks-migration-snapshot.js
 import * as crypto10 from "node:crypto";
-import * as fs74 from "node:fs";
+import * as fs75 from "node:fs";
 import * as os42 from "node:os";
 import * as path73 from "node:path";
 function migrationSnapshotsDir2() {
@@ -19219,41 +19345,41 @@ function writeMetaHooksSnapshot(originalSettings) {
   };
   const validated = MetaHooksMigrationSnapshotSchema.parse(snapshot);
   const dir = migrationSnapshotsDir2();
-  fs74.mkdirSync(dir, { recursive: true });
+  fs75.mkdirSync(dir, { recursive: true });
   const stamp = validated.takenAt.replace(/[:.]/g, "-");
   const rand = crypto10.randomBytes(3).toString("hex");
   const file = path73.join(dir, `${META_HOOKS_SNAPSHOT_PREFIX}${stamp}-${process.pid}-${rand}.json`);
-  fs74.writeFileSync(file, JSON.stringify(validated, null, 2) + "\n", { mode: 384 });
+  fs75.writeFileSync(file, JSON.stringify(validated, null, 2) + "\n", { mode: 384 });
   return file;
 }
 function readMetaHooksSnapshot(filePath) {
-  if (!fs74.existsSync(filePath)) {
+  if (!fs75.existsSync(filePath)) {
     throw new Error(`snapshot file not found: ${filePath}`);
   }
-  const raw = fs74.readFileSync(filePath, "utf-8");
+  const raw = fs75.readFileSync(filePath, "utf-8");
   const parsed = JSON.parse(raw);
   return MetaHooksMigrationSnapshotSchema.parse(parsed);
 }
 function findLatestMetaHooksSnapshot() {
   const dir = migrationSnapshotsDir2();
-  if (!fs74.existsSync(dir))
+  if (!fs75.existsSync(dir))
     return void 0;
-  const candidates2 = fs74.readdirSync(dir).filter((n) => n.startsWith(META_HOOKS_SNAPSHOT_PREFIX) && n.endsWith(".json")).sort().reverse();
+  const candidates2 = fs75.readdirSync(dir).filter((n) => n.startsWith(META_HOOKS_SNAPSHOT_PREFIX) && n.endsWith(".json")).sort().reverse();
   if (candidates2.length === 0)
     return void 0;
   return path73.join(dir, candidates2[0]);
 }
 function restoreSettingsFromSnapshot(snapshot, settingsPath) {
   if (snapshot.originalSettings === null) {
-    if (fs74.existsSync(settingsPath)) {
-      fs74.unlinkSync(settingsPath);
+    if (fs75.existsSync(settingsPath)) {
+      fs75.unlinkSync(settingsPath);
     }
     return;
   }
-  fs74.mkdirSync(path73.dirname(settingsPath), { recursive: true });
+  fs75.mkdirSync(path73.dirname(settingsPath), { recursive: true });
   const tmp = `${settingsPath}.tmp-restore-${process.pid}-${Date.now()}`;
-  fs74.writeFileSync(tmp, JSON.stringify(snapshot.originalSettings, null, 2) + "\n");
-  fs74.renameSync(tmp, settingsPath);
+  fs75.writeFileSync(tmp, JSON.stringify(snapshot.originalSettings, null, 2) + "\n");
+  fs75.renameSync(tmp, settingsPath);
 }
 var META_HOOKS_SNAPSHOT_SCHEMA_VERSION, META_HOOKS_SNAPSHOT_PREFIX, SettingsLooseSchema, MetaHooksMigrationSnapshotSchema;
 var init_meta_hooks_migration_snapshot = __esm({
@@ -19393,6 +19519,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) {
@@ -19400,6 +19528,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) {
@@ -19430,10 +19559,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"
   };
 }
@@ -19467,6 +19616,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 ?? {} };
@@ -19485,7 +19668,7 @@ var init_meta_hook_injector = __esm({
 
 // ../core/dist/lib/markdown-merger.js
 import { createHash as createHash9 } from "node:crypto";
-import { readFileSync as readFileSync72, existsSync as existsSync81, statSync as statSync23 } from "node:fs";
+import { readFileSync as readFileSync74, existsSync as existsSync83, statSync as statSync23 } from "node:fs";
 function parseFrontmatter3(text) {
   const match2 = FM_RE2.exec(text);
   if (match2 === null)
@@ -19614,9 +19797,9 @@ function mergeMarkdown(upstreamText, overlayText, labelForError, upstreamPath, o
   return { merged: fmBlock !== "" ? fmBlock + mergedBody : mergedBody };
 }
 function sha256OfPath(p) {
-  if (!existsSync81(p) || !statSync23(p).isFile())
+  if (!existsSync83(p) || !statSync23(p).isFile())
     return "MISSING";
-  return createHash9("sha256").update(readFileSync72(p)).digest("hex");
+  return createHash9("sha256").update(readFileSync74(p)).digest("hex");
 }
 var FM_RE2, H2_RE;
 var init_markdown_merger = __esm({
@@ -19628,7 +19811,7 @@ var init_markdown_merger = __esm({
 });
 
 // ../core/dist/skill-sync/managed-merge.js
-import * as fs75 from "node:fs";
+import * as fs76 from "node:fs";
 import * as path74 from "node:path";
 function materializeMergedSkill(opts) {
   const { sourceId, sourcePath, deployBasename, mergedContent, claudeDir: claudeDir2 } = opts;
@@ -19638,12 +19821,12 @@ function materializeMergedSkill(opts) {
   if (!(managedResolved === sourceRoot || managedResolved.startsWith(sourceRoot + path74.sep))) {
     throw new Error(`[managed-merge] refusing to materialize: deployBasename "${deployBasename}" escapes managed root "${sourceRoot}" (resolved to "${managedResolved}")`);
   }
-  fs75.mkdirSync(managedDir, { recursive: true });
+  fs76.mkdirSync(managedDir, { recursive: true });
   const skillMdPath = path74.join(managedDir, "SKILL.md");
   const tmpPath = `${skillMdPath}.tmp-${process.pid}-${Date.now()}`;
-  fs75.writeFileSync(tmpPath, mergedContent);
-  fs75.renameSync(tmpPath, skillMdPath);
-  const baseEntries = fs75.readdirSync(sourcePath);
+  fs76.writeFileSync(tmpPath, mergedContent);
+  fs76.renameSync(tmpPath, skillMdPath);
+  const baseEntries = fs76.readdirSync(sourcePath);
   for (const entry of baseEntries) {
     if (entry === "SKILL.md")
       continue;
@@ -19651,13 +19834,13 @@ function materializeMergedSkill(opts) {
     const targetAbsolute = path74.join(sourcePath, entry);
     const targetRelative = path74.relative(managedDir, targetAbsolute);
     try {
-      fs75.lstatSync(linkPath);
-      fs75.rmSync(linkPath, { recursive: true, force: true });
+      fs76.lstatSync(linkPath);
+      fs76.rmSync(linkPath, { recursive: true, force: true });
     } catch {
     }
-    fs75.symlinkSync(targetRelative, linkPath);
+    fs76.symlinkSync(targetRelative, linkPath);
   }
-  const managedEntries = fs75.readdirSync(managedDir);
+  const managedEntries = fs76.readdirSync(managedDir);
   const baseEntrySet = new Set(baseEntries);
   for (const entry of managedEntries) {
     if (entry === "SKILL.md")
@@ -19665,7 +19848,7 @@ function materializeMergedSkill(opts) {
     if (!baseEntrySet.has(entry)) {
       const stalePath = path74.join(managedDir, entry);
       try {
-        fs75.rmSync(stalePath, { recursive: true, force: true });
+        fs76.rmSync(stalePath, { recursive: true, force: true });
       } catch {
       }
     }
@@ -19673,7 +19856,7 @@ function materializeMergedSkill(opts) {
   return managedDir;
 }
 function cleanMergedDir(claudeDir2) {
-  fs75.rmSync(path74.join(claudeDir2, ".olam-merged"), { recursive: true, force: true });
+  fs76.rmSync(path74.join(claudeDir2, ".olam-merged"), { recursive: true, force: true });
 }
 var init_managed_merge = __esm({
   "../core/dist/skill-sync/managed-merge.js"() {
@@ -19812,7 +19995,7 @@ var init_prefix_rules = __esm({
 });
 
 // ../core/dist/skill-sync/prefix-deploy.js
-import * as fs76 from "node:fs";
+import * as fs77 from "node:fs";
 import * as path75 from "node:path";
 function buildSourcePrefixMap(sources) {
   const byId = /* @__PURE__ */ new Map();
@@ -19868,7 +20051,7 @@ function applyPrefixRewrites(baseArtifacts, sourceMap, claudeDir2, dryRun) {
     }
     if (artifact.kind === "skill") {
       const skillMdPath = path75.join(artifact.sourcePath, "SKILL.md");
-      const content = fs76.readFileSync(skillMdPath);
+      const content = fs77.readFileSync(skillMdPath);
       const rewritten = rewriteFrontmatterName(content, () => renamedFrontmatterName);
       const managedDir = materializeMergedSkill({
         sourceId: artifact.sourceId,
@@ -19880,7 +20063,7 @@ function applyPrefixRewrites(baseArtifacts, sourceMap, claudeDir2, dryRun) {
       artifact.sourcePath = managedDir;
       artifact.deployBasename = renamed;
     } else {
-      const content = artifact.resolvedContent !== void 0 ? artifact.resolvedContent : fs76.readFileSync(artifact.sourcePath);
+      const content = artifact.resolvedContent !== void 0 ? artifact.resolvedContent : fs77.readFileSync(artifact.sourcePath);
       const rewritten = rewriteFrontmatterName(content, () => renamedFrontmatterName);
       artifact.resolvedContent = rewritten;
       artifact.deployBasename = renamed;
@@ -19925,19 +20108,19 @@ var init_prefix_deploy = __esm({
 });
 
 // ../core/dist/skill-sync/resolve-source-config.js
-import { readFileSync as readFileSync74, existsSync as existsSync82 } from "node:fs";
-import { join as join83 } from "node:path";
+import { readFileSync as readFileSync76, existsSync as existsSync84 } from "node:fs";
+import { join as join84 } from "node:path";
 import { parse as parseYaml7 } from "yaml";
 function sourceConfigPath(clonePath) {
-  return join83(clonePath, "shared", "source-config.yaml");
+  return join84(clonePath, "shared", "source-config.yaml");
 }
 function readSourceConfig(clonePath, sourceId) {
   const path106 = sourceConfigPath(clonePath);
-  if (!existsSync82(path106))
+  if (!existsSync84(path106))
     return void 0;
   let raw;
   try {
-    raw = readFileSync74(path106, "utf-8");
+    raw = readFileSync76(path106, "utf-8");
   } catch (err) {
     emitMalformedWarning(sourceId, `read failed: ${errToMsg(err)}`);
     return void 0;
@@ -20032,7 +20215,7 @@ var init_resolve_source_config = __esm({
 });
 
 // ../core/dist/skill-sync/engine.js
-import * as fs77 from "node:fs";
+import * as fs78 from "node:fs";
 import * as os43 from "node:os";
 import * as path76 from "node:path";
 function resolveAtlasUser(override) {
@@ -20040,8 +20223,8 @@ function resolveAtlasUser(override) {
     return override;
   const claudeDir2 = process.env["OLAM_CLAUDE_DIR"] || path76.join(os43.homedir(), ".claude");
   const f = path76.join(claudeDir2, ".atlas-user");
-  if (fs77.existsSync(f)) {
-    return fs77.readFileSync(f, "utf-8").trim() || void 0;
+  if (fs78.existsSync(f)) {
+    return fs78.readFileSync(f, "utf-8").trim() || void 0;
   }
   return void 0;
 }
@@ -20053,7 +20236,7 @@ async function syncSkills(opts = {}) {
   const perSource = [];
   for (const source of sources) {
     const clonePath = skillSourceClonePath(source.id);
-    if (!fs77.existsSync(clonePath))
+    if (!fs78.existsSync(clonePath))
       continue;
     const { artifacts, subscription } = await withFileLock(clonePath, () => {
       const pinRef = projectOverride?.override.pin?.[source.id];
@@ -20093,7 +20276,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 = fs77.existsSync(clonePath) ? readSourceConfig(clonePath, s.id) : void 0;
+    const sourceConfig = fs78.existsSync(clonePath) ? readSourceConfig(clonePath, s.id) : void 0;
     const eff = resolveEffectivePrefix(s, sourceConfig);
     const entry = {
       id: s.id,
@@ -20200,12 +20383,12 @@ async function syncSkills(opts = {}) {
       let basePath;
       if (overlay.targetKind === "skill") {
         basePath = path76.join(base.sourcePath, "SKILL.md");
-        baseContent = fs77.readFileSync(basePath, "utf-8");
+        baseContent = fs78.readFileSync(basePath, "utf-8");
       } else {
         basePath = base.sourcePath;
-        baseContent = fs77.readFileSync(basePath, "utf-8");
+        baseContent = fs78.readFileSync(basePath, "utf-8");
       }
-      const overlayContent = fs77.readFileSync(overlay.sourcePath, "utf-8");
+      const overlayContent = fs78.readFileSync(overlay.sourcePath, "utf-8");
       const label = `${overlay.sourceId}/${overlay.deployBasename}`;
       const mergeResult = mergeMarkdown(baseContent, overlayContent, label, basePath, overlay.sourcePath);
       if ("error" in mergeResult) {
@@ -20287,24 +20470,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 (fs77.existsSync(settingsFile)) {
+    if (fs78.existsSync(settingsFile)) {
       settingsExisted = true;
       try {
-        const raw = fs77.readFileSync(settingsFile, "utf-8");
+        const raw = fs78.readFileSync(settingsFile, "utf-8");
         currentSettings = raw.trim() ? JSON.parse(raw) : {};
       } catch {
         try {
-          const raw = fs77.readFileSync(settingsFile);
+          const raw = fs78.readFileSync(settingsFile);
           const bakDir = path76.join(path76.dirname(settingsFile), ".malformed-backups");
-          fs77.mkdirSync(bakDir, { recursive: true });
+          fs78.mkdirSync(bakDir, { recursive: true });
           const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
           const bakFile = path76.join(bakDir, `settings.json.malformed.${stamp}.bak`);
-          fs77.writeFileSync(bakFile, raw, { mode: 384 });
+          fs78.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)}`;
@@ -20315,16 +20508,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: servicesStatus2,
       currentSettings: settingsForInject,
@@ -20354,17 +20537,34 @@ async function injectMetaHooksIntoSettings(opts) {
       } catch {
       }
     }
-    fs77.mkdirSync(path76.dirname(settingsFile), { recursive: true });
+    fs78.mkdirSync(path76.dirname(settingsFile), { recursive: true });
     const tmpPath = `${settingsFile}.tmp-${process.pid}-${Date.now()}`;
-    fs77.writeFileSync(tmpPath, JSON.stringify(inject.nextSettings, null, 2) + "\n");
-    fs77.renameSync(tmpPath, settingsFile);
+    fs78.writeFileSync(tmpPath, JSON.stringify(inject.nextSettings, null, 2) + "\n");
+    fs78.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: path76.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: servicesStatus2,
     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 } } : {}
   };
@@ -20389,6 +20589,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();
@@ -20398,7 +20599,7 @@ var init_engine = __esm({
 });
 
 // ../core/dist/skill-sync/shadow-backup-manager.js
-import * as fs78 from "node:fs";
+import * as fs79 from "node:fs";
 import * as path77 from "node:path";
 function listShadowBackups(opts = {}) {
   const claude = opts.claudeDirOverride ?? claudeDir();
@@ -20406,11 +20607,11 @@ function listShadowBackups(opts = {}) {
   const out = [];
   for (const bucket of SHADOW_BACKUP_BUCKETS) {
     const bucketDir = path77.join(claude, bucket);
-    if (!fs78.existsSync(bucketDir))
+    if (!fs79.existsSync(bucketDir))
       continue;
     let entries;
     try {
-      entries = fs78.readdirSync(bucketDir);
+      entries = fs79.readdirSync(bucketDir);
     } catch {
       continue;
     }
@@ -20424,7 +20625,7 @@ function listShadowBackups(opts = {}) {
       const full = path77.join(bucketDir, name);
       let sizeBytes = 0;
       try {
-        const st = fs78.statSync(full);
+        const st = fs79.statSync(full);
         if (st.isDirectory())
           continue;
         sizeBytes = st.size;
@@ -20480,7 +20681,7 @@ function pruneShadowBackups(opts) {
     }
     if (!opts.dryRun) {
       try {
-        fs78.unlinkSync(b.path);
+        fs79.unlinkSync(b.path);
       } catch {
         skipped.push(b);
         continue;
@@ -20492,7 +20693,7 @@ function pruneShadowBackups(opts) {
 }
 function restoreShadowBackup(opts) {
   const abs = path77.resolve(opts.backupPath);
-  if (!fs78.existsSync(abs)) {
+  if (!fs79.existsSync(abs)) {
     throw new Error(`backup file not found: ${abs}`);
   }
   const basename17 = path77.basename(abs);
@@ -20502,13 +20703,13 @@ function restoreShadowBackup(opts) {
   }
   const originalBasename = basename17.slice(0, basename17.length - match2[0].length);
   const originalPath = path77.join(path77.dirname(abs), originalBasename);
-  if (fs78.existsSync(originalPath) && !opts.force) {
+  if (fs79.existsSync(originalPath) && !opts.force) {
     throw new Error(`original path already occupied: ${originalPath}. Move/rename it first OR re-run with --force.`);
   }
-  if (opts.force && fs78.existsSync(originalPath)) {
-    fs78.unlinkSync(originalPath);
+  if (opts.force && fs79.existsSync(originalPath)) {
+    fs79.unlinkSync(originalPath);
   }
-  fs78.renameSync(abs, originalPath);
+  fs79.renameSync(abs, originalPath);
   return { restoredTo: originalPath };
 }
 var SHADOW_BACKUP_BUCKETS, SHADOW_BACKUP_SUFFIX_RE;
@@ -20522,7 +20723,7 @@ var init_shadow_backup_manager = __esm({
 });
 
 // ../core/dist/global-config/repos.js
-import * as fs79 from "node:fs";
+import * as fs80 from "node:fs";
 import * as os44 from "node:os";
 import * as path78 from "node:path";
 function expandPath(p) {
@@ -20540,7 +20741,7 @@ function addRepo(entry) {
     throw new Error(`repo "${entry.name}" already registered. Use "olam repos update" to change its path.`);
   }
   const resolvedPath = expandPath(entry.path);
-  if (!fs79.existsSync(resolvedPath)) {
+  if (!fs80.existsSync(resolvedPath)) {
     throw new Error(`path "${entry.path}" does not exist. Verify the path is correct.`);
   }
   const now = Date.now();
@@ -20569,7 +20770,7 @@ function updateRepo(name, updates) {
     throw new Error(`repo "${name}" is not registered. Run "olam repos list" to see registered repos.`);
   }
   const resolvedUpdatePath = updates.path !== void 0 ? expandPath(updates.path) : void 0;
-  if (resolvedUpdatePath !== void 0 && !fs79.existsSync(resolvedUpdatePath)) {
+  if (resolvedUpdatePath !== void 0 && !fs80.existsSync(resolvedUpdatePath)) {
     throw new Error(`path "${updates.path}" does not exist. Verify the path is correct.`);
   }
   const existing = config.repos[idx];
@@ -20638,7 +20839,7 @@ var init_global_config = __esm({
 });
 
 // ../core/dist/skill-sources/doctor-checks.js
-import * as fs80 from "node:fs";
+import * as fs81 from "node:fs";
 import * as path79 from "node:path";
 import * as os45 from "node:os";
 function claudeDirInternal3() {
@@ -20654,11 +20855,11 @@ function checkStateFileParse() {
     healthy: true,
     description: `~/.olam state file (${filePath})`
   };
-  if (!fs80.existsSync(filePath)) {
+  if (!fs81.existsSync(filePath)) {
     result.details = ["(file does not yet exist \u2014 will be created on first write)"];
     return result;
   }
-  const raw = fs80.readFileSync(filePath, "utf-8");
+  const raw = fs81.readFileSync(filePath, "utf-8");
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -20668,8 +20869,8 @@ function checkStateFileParse() {
     result.details = [err instanceof Error ? err.message : String(err)];
     result.repair = () => {
       const aside = `${filePath}.corrupt-${Math.floor(Date.now() / 1e3)}`;
-      fs80.renameSync(filePath, aside);
-      fs80.writeFileSync(filePath, JSON.stringify({ schemaVersion: 1, repos: [], runbooks: [], skillSources: [] }, null, 2));
+      fs81.renameSync(filePath, aside);
+      fs81.writeFileSync(filePath, JSON.stringify({ schemaVersion: 1, repos: [], runbooks: [], skillSources: [] }, null, 2));
     };
     return result;
   }
@@ -20680,7 +20881,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)}`;
-      fs80.copyFileSync(filePath, aside);
+      fs81.copyFileSync(filePath, aside);
       const base = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
       const next = {
         ...base,
@@ -20689,7 +20890,7 @@ function checkStateFileParse() {
         runbooks: [],
         skillSources: []
       };
-      fs80.writeFileSync(filePath, JSON.stringify(next, null, 2));
+      fs81.writeFileSync(filePath, JSON.stringify(next, null, 2));
     };
     return result;
   }
@@ -20701,15 +20902,15 @@ function checkDanglingSymlinks() {
   const dangling = [];
   for (const bucket of buckets) {
     const dir = path79.join(claude, bucket);
-    if (!fs80.existsSync(dir))
+    if (!fs81.existsSync(dir))
       continue;
-    for (const name of fs80.readdirSync(dir)) {
+    for (const name of fs81.readdirSync(dir)) {
       const linkPath = path79.join(dir, name);
       try {
-        const lst = fs80.lstatSync(linkPath);
+        const lst = fs81.lstatSync(linkPath);
         if (!lst.isSymbolicLink())
           continue;
-        if (!fs80.existsSync(linkPath)) {
+        if (!fs81.existsSync(linkPath)) {
           dangling.push(linkPath);
         }
       } catch {
@@ -20727,7 +20928,7 @@ function checkDanglingSymlinks() {
     result.repair = () => {
       for (const p of dangling) {
         try {
-          fs80.unlinkSync(p);
+          fs81.unlinkSync(p);
         } catch {
         }
       }
@@ -20742,19 +20943,19 @@ function checkOrphanedSnapshots() {
     healthy: true,
     description: `orphaned migration snapshots under ${dir}`
   };
-  if (!fs80.existsSync(dir)) {
+  if (!fs81.existsSync(dir)) {
     return result;
   }
   const orphans = [];
-  for (const name of fs80.readdirSync(dir)) {
+  for (const name of fs81.readdirSync(dir)) {
     if (!name.endsWith(".json"))
       continue;
     const full = path79.join(dir, name);
     try {
-      const stat = fs80.statSync(full);
+      const stat = fs81.statSync(full);
       if (!stat.isFile())
         continue;
-      const raw = fs80.readFileSync(full, "utf-8");
+      const raw = fs81.readFileSync(full, "utf-8");
       let parsed;
       try {
         parsed = JSON.parse(raw);
@@ -20779,7 +20980,7 @@ function checkOrphanedSnapshots() {
     result.repair = () => {
       for (const o of orphans) {
         try {
-          fs80.unlinkSync(o.path);
+          fs81.unlinkSync(o.path);
         } catch {
         }
       }
@@ -20794,12 +20995,12 @@ function checkSentinelDrift() {
     healthy: true,
     description: `olam-skills sentinel block in ${filePath}`
   };
-  if (!fs80.existsSync(filePath)) {
+  if (!fs81.existsSync(filePath)) {
     return result;
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs80.readFileSync(filePath, "utf-8"));
+    parsed = JSON.parse(fs81.readFileSync(filePath, "utf-8"));
   } catch {
     return result;
   }
@@ -20840,7 +21041,7 @@ function checkSentinelDrift() {
         backupSettings();
       } catch {
       }
-      const next = JSON.parse(fs80.readFileSync(filePath, "utf-8"));
+      const next = JSON.parse(fs81.readFileSync(filePath, "utf-8"));
       if (!next.hooks)
         return;
       for (const stage of Object.keys(next.hooks)) {
@@ -20863,7 +21064,7 @@ function checkSentinelDrift() {
           return bad === void 0;
         });
       }
-      fs80.writeFileSync(filePath, JSON.stringify(next, null, 2) + "\n");
+      fs81.writeFileSync(filePath, JSON.stringify(next, null, 2) + "\n");
     };
   }
   return result;
@@ -20888,7 +21089,7 @@ function checkMemberNameMissing() {
   }
   const claudeDir2 = claudeDirInternal3();
   const atlasUserPath = path79.join(claudeDir2, ".atlas-user");
-  const value = fs80.existsSync(atlasUserPath) ? fs80.readFileSync(atlasUserPath, "utf-8").trim() : "";
+  const value = fs81.existsSync(atlasUserPath) ? fs81.readFileSync(atlasUserPath, "utf-8").trim() : "";
   if (value.length > 0) {
     result.details = [`atlas-user: ${value}`];
     return result;
@@ -20897,9 +21098,9 @@ function checkMemberNameMissing() {
   result.issue = "atlas-toolbox source registered but ~/.claude/.atlas-user not set";
   const clonePath = skillSourceClonePath(atlasSource.id);
   const membersDir = path79.join(clonePath, "members");
-  const existing = fs80.existsSync(membersDir) ? fs80.readdirSync(membersDir).filter((e) => {
+  const existing = fs81.existsSync(membersDir) ? fs81.readdirSync(membersDir).filter((e) => {
     try {
-      return fs80.statSync(path79.join(membersDir, e)).isDirectory();
+      return fs81.statSync(path79.join(membersDir, e)).isDirectory();
     } catch {
       return false;
     }
@@ -20914,7 +21115,7 @@ function checkMemberNameMissing() {
 function checkMemberOverlayDrift() {
   const claudeDir2 = claudeDirInternal3();
   const atlasUserPath = path79.join(claudeDir2, ".atlas-user");
-  const atlasUser = fs80.existsSync(atlasUserPath) ? fs80.readFileSync(atlasUserPath, "utf-8").trim() : "";
+  const atlasUser = fs81.existsSync(atlasUserPath) ? fs81.readFileSync(atlasUserPath, "utf-8").trim() : "";
   if (atlasUser.length === 0) {
     return [];
   }
@@ -20931,11 +21132,11 @@ function checkMemberOverlayDrift() {
   const results = [];
   for (const kind of ["skills", "agents"]) {
     const localRoot = path79.join(claudeDir2, `${kind}.overrides`);
-    if (!fs80.existsSync(localRoot))
+    if (!fs81.existsSync(localRoot))
       continue;
     let entries;
     try {
-      entries = fs80.readdirSync(localRoot);
+      entries = fs81.readdirSync(localRoot);
     } catch {
       continue;
     }
@@ -20943,7 +21144,7 @@ function checkMemberOverlayDrift() {
       const localFile = path79.join(localRoot, entry);
       let stat;
       try {
-        stat = fs80.statSync(localFile);
+        stat = fs81.statSync(localFile);
       } catch {
         continue;
       }
@@ -21119,7 +21320,7 @@ __export(project_sweep_exports, {
   walkProjectRoot: () => walkProjectRoot
 });
 import * as path80 from "node:path";
-import { readdirSync as readdirSync26, lstatSync as lstatSync6, statSync as statSync26, existsSync as existsSync87 } from "node:fs";
+import { readdirSync as readdirSync26, lstatSync as lstatSync6, statSync as statSync26, existsSync as existsSync89 } from "node:fs";
 function isSkipped(basename17, extra) {
   if (DEFAULT_SKIP.has(basename17))
     return true;
@@ -21198,7 +21399,7 @@ function makeRealFsAdapter() {
       const s = statSync26(p, { throwIfNoEntry: true });
       return { isDirectory: () => s.isDirectory(), mtimeMs: s.mtimeMs };
     },
-    existsSync: (p) => existsSync87(p)
+    existsSync: (p) => existsSync89(p)
   };
 }
 function walkProjectRoot(rootPath, opts = {}) {
@@ -21224,7 +21425,7 @@ __export(kg_eager_exports, {
   runEagerKgBuild: () => runEagerKgBuild,
   writeQueue: () => writeQueue
 });
-import * as fs81 from "node:fs";
+import * as fs82 from "node:fs";
 import * as path81 from "node:path";
 import * as os46 from "node:os";
 function defaultQueuePath() {
@@ -21232,9 +21433,9 @@ function defaultQueuePath() {
   return path81.join(stateDir, "kg-pending.jsonl");
 }
 function readQueue(queuePath) {
-  if (!fs81.existsSync(queuePath))
+  if (!fs82.existsSync(queuePath))
     return [];
-  const raw = fs81.readFileSync(queuePath, "utf-8");
+  const raw = fs82.readFileSync(queuePath, "utf-8");
   const entries = [];
   for (const line of raw.split("\n")) {
     const trimmed = line.trim();
@@ -21248,16 +21449,16 @@ function readQueue(queuePath) {
   return entries;
 }
 function writeQueue(queuePath, entries) {
-  fs81.mkdirSync(path81.dirname(queuePath), { recursive: true });
+  fs82.mkdirSync(path81.dirname(queuePath), { recursive: true });
   const content = entries.map((e) => JSON.stringify(e)).join("\n") + (entries.length > 0 ? "\n" : "");
-  fs81.writeFileSync(queuePath, content, "utf-8");
+  fs82.writeFileSync(queuePath, content, "utf-8");
 }
 function appendQueue(queuePath, repos, nowMs) {
   if (repos.length === 0)
     return;
-  fs81.mkdirSync(path81.dirname(queuePath), { recursive: true });
+  fs82.mkdirSync(path81.dirname(queuePath), { recursive: true });
   const lines = repos.map((r) => JSON.stringify({ path: r.path, addedAt: nowMs })).join("\n") + "\n";
-  fs81.appendFileSync(queuePath, lines, "utf-8");
+  fs82.appendFileSync(queuePath, lines, "utf-8");
 }
 async function defaultBuildOne(_repo) {
   return { ok: true, ms: 0 };
@@ -21397,27 +21598,27 @@ var init_install_shared = __esm({
 });
 
 // src/commands/memory/_paths.ts
-import { homedir as homedir52 } from "node:os";
-import { join as join92, dirname as dirname49 } from "node:path";
-import { fileURLToPath as fileURLToPath8 } from "node:url";
+import { homedir as homedir53 } from "node:os";
+import { join as join93, dirname as dirname50 } from "node:path";
+import { fileURLToPath as fileURLToPath9 } from "node:url";
 var OLAM_HOME5, MEMORY_PID_PATH, MEMORY_LOG_PATH, MEMORY_DATA_DIR, MEMORY_REST_PORT, MEMORY_LIVEZ_URL, here, candidates, MEMORY_SERVICE_CANDIDATES;
 var init_paths2 = __esm({
   "src/commands/memory/_paths.ts"() {
     "use strict";
-    OLAM_HOME5 = join92(homedir52(), ".olam");
-    MEMORY_PID_PATH = join92(OLAM_HOME5, "memory.pid");
-    MEMORY_LOG_PATH = join92(OLAM_HOME5, "memory-service.log");
-    MEMORY_DATA_DIR = join92(OLAM_HOME5, "memory-data");
+    OLAM_HOME5 = join93(homedir53(), ".olam");
+    MEMORY_PID_PATH = join93(OLAM_HOME5, "memory.pid");
+    MEMORY_LOG_PATH = join93(OLAM_HOME5, "memory-service.log");
+    MEMORY_DATA_DIR = join93(OLAM_HOME5, "memory-data");
     MEMORY_REST_PORT = 3111;
     MEMORY_LIVEZ_URL = `http://localhost:${MEMORY_REST_PORT}/agentmemory/livez`;
-    here = dirname49(fileURLToPath8(import.meta.url));
+    here = dirname50(fileURLToPath9(import.meta.url));
     candidates = [
       // 1. Workspace dev (built): packages/cli/dist/commands/memory/_paths.js → packages/cli → packages/memory-service
-      join92(here, "..", "..", "..", "..", "memory-service"),
+      join93(here, "..", "..", "..", "..", "memory-service"),
       // 2. Workspace bundled: packages/cli/dist/index.js → packages/cli → packages/memory-service
-      join92(here, "..", "..", "memory-service"),
+      join93(here, "..", "..", "memory-service"),
       // 3. CWD fallback
-      join92(process.cwd(), "packages", "memory-service")
+      join93(process.cwd(), "packages", "memory-service")
     ];
     MEMORY_SERVICE_CANDIDATES = candidates;
   }
@@ -21526,16 +21727,16 @@ __export(machine_schema_exports, {
   readMachineConfig: () => readMachineConfig,
   writeMachineConfig: () => writeMachineConfig
 });
-import * as fs85 from "node:fs";
+import * as fs86 from "node:fs";
 import * as path86 from "node:path";
 import * as os48 from "node:os";
 import { parse as parseYaml8, stringify as stringifyYaml6 } from "yaml";
 function readMachineConfig(configPath) {
   const p = configPath ?? DEFAULT_CONFIG_PATH;
-  if (!fs85.existsSync(p))
+  if (!fs86.existsSync(p))
     return null;
   try {
-    const raw = fs85.readFileSync(p, "utf-8");
+    const raw = fs86.readFileSync(p, "utf-8");
     const parsed = parseYaml8(raw);
     return MachineConfigSchema.parse(parsed);
   } catch {
@@ -21544,8 +21745,8 @@ function readMachineConfig(configPath) {
 }
 function writeMachineConfig(config, configPath) {
   const p = configPath ?? DEFAULT_CONFIG_PATH;
-  fs85.mkdirSync(path86.dirname(p), { recursive: true });
-  fs85.writeFileSync(p, stringifyYaml6({ ...config }), { mode: 420 });
+  fs86.mkdirSync(path86.dirname(p), { recursive: true });
+  fs86.writeFileSync(p, stringifyYaml6({ ...config }), { mode: 420 });
 }
 function initMachineConfig(opts = {}) {
   const configPath = opts.configPath ?? DEFAULT_CONFIG_PATH;
@@ -21671,7 +21872,7 @@ function registerWorkspace(program2) {
       process.exitCode = 1;
     }
   });
-  workspace.command("remove").description("Delete a workspace (does NOT touch worlds that already referenced it)").argument("<name>", "Workspace name").option("--force", "Skip confirmation", false).action((name, _opts) => {
+  workspace.command("remove").description("Delete a workspace (does NOT touch worlds that already referenced it)").argument("<name>", "Workspace name").action((name) => {
     try {
       if (removeWorkspace(name)) {
         printSuccess(`Removed workspace "${name}"`);
@@ -22040,7 +22241,7 @@ function runGlobalInit(opts) {
   }
 }
 function registerInit(program2) {
-  program2.command("init").description("Initialize olam in the current project or globally").option("--path <path>", "Project root path", process.cwd()).option("--skip-pleri", "Skip Pleri setup (deprecated \u2014 PLERI is always optional)").option("--global", "Write only ~/.olam/config.json (global scope); skip per-repo .olam/config.yaml").option("--project", "Write .olam/config.yaml in the nearest git repo (per-repo scope; default when --global is absent)").option("--yes / -y", "Auto-affirm prompts (non-interactive)").action(async (opts) => {
+  program2.command("init").description("Initialize olam in the current project or globally").option("--path <path>", "Project root path", process.cwd()).option("--skip-pleri", "No-op (deprecated \u2014 PLERI is always optional; accepted for backward compat but has no effect)").option("--global", "Write only ~/.olam/config.json (global scope); skip per-repo .olam/config.yaml").option("--project", "Write .olam/config.yaml in the nearest git repo (per-repo scope; default when --global is absent)").option("--yes / -y", "Auto-affirm prompts (non-interactive)").action(async (opts) => {
     if (opts.global) {
       try {
         const result = runGlobalInit({});
@@ -22594,7 +22795,7 @@ async function kubectlWrap(args, opts = {}) {
   const spawnImpl = opts.spawnImpl ?? spawn4;
   const stdout = [];
   const stderr = [];
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     let resolved = false;
     let killTimer = null;
     let sigkillTimer = null;
@@ -22609,7 +22810,7 @@ async function kubectlWrap(args, opts = {}) {
         clearTimeout(sigkillTimer);
         sigkillTimer = null;
       }
-      resolve30(r);
+      resolve31(r);
     }
     let child;
     try {
@@ -22618,7 +22819,7 @@ async function kubectlWrap(args, opts = {}) {
         env: { ...process.env, ...opts.env ?? {} }
       });
     } catch (err) {
-      resolve30({
+      resolve31({
         ok: false,
         stdout: "",
         stderr: err instanceof Error ? err.message : String(err),
@@ -23134,7 +23335,7 @@ function runLiveTask(label, cmd, args, opts) {
   const startMs = Date.now();
   const settle = opts.settle ?? "auto";
   const useSpinner = !opts.verbose && Boolean(process.stdout.isTTY);
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     const child = spawn5(cmd, [...args], {
       env: opts.env ?? process.env,
       stdio: ["ignore", "pipe", "pipe"]
@@ -23198,7 +23399,7 @@ function runLiveTask(label, cmd, args, opts) {
           );
         }
       }
-      resolve30({ ok, exitCode: code, durationMs, logPath });
+      resolve31({ ok, exitCode: code, durationMs, logPath });
     };
     child.on("error", (err) => {
       chunks.push(`
@@ -24388,10 +24589,10 @@ async function confirm(message) {
   if (!process.stdin.isTTY) return true;
   const { createInterface: createInterface12 } = await import("node:readline");
   const rl = createInterface12({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     rl.question(`${message} [y/N] `, (answer) => {
       rl.close();
-      resolve30(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      resolve31(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
   });
 }
@@ -24863,7 +25064,7 @@ var KgServiceContainerController = class {
   }
 };
 function sleep4(ms) {
-  return new Promise((resolve30) => setTimeout(resolve30, ms));
+  return new Promise((resolve31) => setTimeout(resolve31, ms));
 }
 
 // src/commands/memory-service-container.ts
@@ -25086,7 +25287,7 @@ var MemoryServiceContainerController = class {
   }
 };
 function sleep5(ms) {
-  return new Promise((resolve30) => setTimeout(resolve30, ms));
+  return new Promise((resolve31) => setTimeout(resolve31, ms));
 }
 
 // src/lib/peripheral-registry.ts
@@ -25681,7 +25882,7 @@ var McpAuthContainerController = class {
   }
 };
 function sleep6(ms) {
-  return new Promise((resolve30) => setTimeout(resolve30, ms));
+  return new Promise((resolve31) => setTimeout(resolve31, ms));
 }
 var K8S_NAMESPACE2 = "olam";
 function assertK8sContext(configPath) {
@@ -26287,14 +26488,14 @@ async function probePortForwardLiveness(deps = {}) {
   return probe2("127.0.0.1", PORT_FORWARD_PORT, TCP_PROBE_TIMEOUT_MS);
 }
 function realTcpProbe(host, port2, timeoutMs) {
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     const socket = new net3.Socket();
     let done = false;
     function finish(result) {
       if (done) return;
       done = true;
       socket.destroy();
-      resolve30(result);
+      resolve31(result);
     }
     const timer = setTimeout(() => finish(false), timeoutMs);
     socket.once("connect", () => {
@@ -26632,12 +26833,12 @@ function appendAuditEntry(entry, auditLogPath, writeFileSyncImpl) {
 async function runManifestRefresh(manifestsDir, acceptRegression, deps = {}, peripheral) {
   const auditLogPath = deps.auditLogPath ?? MANIFEST_REFRESH_AUDIT_LOG;
   const readdirSync34 = deps.readdirSync ?? fs35.readdirSync;
-  const readFileSync108 = deps.readFileSync ?? fs35.readFileSync;
+  const readFileSync110 = deps.readFileSync ?? fs35.readFileSync;
   const writeFileSyncImpl = deps.writeFileSync ?? fs35.writeFileSync;
-  const existsSync120 = deps.existsSync ?? fs35.existsSync;
+  const existsSync122 = deps.existsSync ?? fs35.existsSync;
   const now = deps.now ? deps.now() : /* @__PURE__ */ new Date();
   const targetDir = peripheral ? path36.join(manifestsDir, peripheral) : manifestsDir;
-  if (!existsSync120(targetDir)) {
+  if (!existsSync122(targetDir)) {
     return {
       ok: false,
       message: peripheral ? `peripheral manifests directory not found: ${targetDir}` : `manifests directory not found: ${targetDir}`
@@ -26658,7 +26859,7 @@ async function runManifestRefresh(manifestsDir, acceptRegression, deps = {}, per
     const filePath = path36.join(targetDir, file);
     let content;
     try {
-      content = readFileSync108(filePath, "utf8");
+      content = readFileSync110(filePath, "utf8");
     } catch {
       continue;
     }
@@ -26914,11 +27115,11 @@ async function checkSecretPreCondition(context, deps) {
 }
 async function applyConfigMapSubstitution(context, manifestsDir, deps) {
   const wrap = deps.kubectlWrapImpl ?? kubectlWrap;
-  const readFileSync108 = deps.readFileSyncImpl ?? fs36.readFileSync;
+  const readFileSync110 = deps.readFileSyncImpl ?? fs36.readFileSync;
   const configMapPath = path37.join(manifestsDir, "30-configmap.yaml");
   let rawYaml;
   try {
-    rawYaml = readFileSync108(configMapPath, "utf8");
+    rawYaml = readFileSync110(configMapPath, "utf8");
   } catch (err) {
     return `Failed to read ConfigMap at ${configMapPath}: ${err instanceof Error ? err.message : String(err)}`;
   }
@@ -28193,10 +28394,10 @@ function emptyMigrationState() {
   return { version: 1, migrated: {} };
 }
 function readMigrationState(statePath, deps) {
-  const existsSync120 = deps.existsSync ?? fs40.existsSync;
-  const readFileSync108 = deps.readFileSync ?? ((p) => fs40.readFileSync(p, "utf-8"));
-  if (!existsSync120(statePath)) return emptyMigrationState();
-  const raw = readFileSync108(statePath);
+  const existsSync122 = deps.existsSync ?? fs40.existsSync;
+  const readFileSync110 = deps.readFileSync ?? ((p) => fs40.readFileSync(p, "utf-8"));
+  if (!existsSync122(statePath)) return emptyMigrationState();
+  const raw = readFileSync110(statePath);
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -28213,17 +28414,17 @@ function readMigrationState(statePath, deps) {
   return parsed;
 }
 function writeMigrationStateAtomic(statePath, state, deps) {
-  const writeFileSync65 = deps.writeFileSync ?? ((p, d) => fs40.writeFileSync(p, d, "utf-8"));
+  const writeFileSync67 = deps.writeFileSync ?? ((p, d) => fs40.writeFileSync(p, d, "utf-8"));
   const renameSync21 = deps.renameSync ?? fs40.renameSync;
   const tmpPath = `${statePath}.tmp`;
-  writeFileSync65(tmpPath, JSON.stringify(state, null, 2) + "\n");
+  writeFileSync67(tmpPath, JSON.stringify(state, null, 2) + "\n");
   renameSync21(tmpPath, statePath);
 }
 function readLocalAccounts(accountsPath, deps) {
-  const existsSync120 = deps.existsSync ?? fs40.existsSync;
-  const readFileSync108 = deps.readFileSync ?? ((p) => fs40.readFileSync(p, "utf-8"));
-  if (!existsSync120(accountsPath)) return null;
-  const raw = readFileSync108(accountsPath);
+  const existsSync122 = deps.existsSync ?? fs40.existsSync;
+  const readFileSync110 = deps.readFileSync ?? ((p) => fs40.readFileSync(p, "utf-8"));
+  if (!existsSync122(accountsPath)) return null;
+  const raw = readFileSync110(accountsPath);
   let parsed;
   try {
     parsed = JSON.parse(raw);
@@ -29108,18 +29309,31 @@ ${pc13.dim("Tip: set ANTHROPIC_BASE_URL=" + baseUrl.replace(/\/+$/, "") + "/v1/p
   auth.command("revoke-anthropic-token").description("Revoke an Anthropic proxy token on the remote auth-worker (g4)").requiredOption("--remote <url>", "Auth-worker base URL").requiredOption("--token-hash <hash>", "Token hash to revoke (from issue or list output)").action(async (opts) => {
     const baseUrl = opts.remote;
     printHeader("Auth worker \u2014 revoke Anthropic proxy token");
-    console.log(`
+    const serviceToken = resolveCfAccessServiceToken();
+    let remoteOpts;
+    if (serviceToken) {
+      console.log(`
+  ${pc13.dim("Using CF Access service token (machine-to-machine; no cookie needed).")}`);
+      remoteOpts = {
+        baseUrl,
+        cfAccessClientId: serviceToken.clientId,
+        cfAccessClientSecret: serviceToken.clientSecret
+      };
+    } else {
+      console.log(`
   Open ${pc13.cyan(baseUrl.replace(/\/+$/, "") + "/v1/oauth/start")} in a browser to authenticate via CF Access SSO.`);
-    console.log(`  Once you've completed SSO, paste your CF_Authorization cookie below.
+      console.log(`  Once you've completed SSO, paste your CF_Authorization cookie below.
 `);
-    const rawCookie = await promptLine(`  ${pc13.dim("CF_Authorization cookie:")} `);
-    if (!rawCookie) {
-      printError("No cookie provided. Aborting.");
-      process.exitCode = 1;
-      return;
+      const rawCookie = await promptLine(`  ${pc13.dim("CF_Authorization cookie:")} `);
+      if (!rawCookie) {
+        printError("No cookie provided. Aborting.");
+        process.exitCode = 1;
+        return;
+      }
+      remoteOpts = { baseUrl, cfAuthCookie: rawCookie };
     }
     try {
-      const revoked = await remoteRevokeAnthropicToken({ baseUrl, cfAuthCookie: rawCookie }, opts.tokenHash);
+      const revoked = await remoteRevokeAnthropicToken(remoteOpts, opts.tokenHash);
       if (revoked) {
         printSuccess(`Token ${opts.tokenHash} revoked.`);
       } else {
@@ -31411,6 +31625,7 @@ Top-level commands (run \`olam <command> --help\` for flags and subcommands):
 - \`olam enter\` \u2014 Open terminal to a world
 - \`olam evict\` \u2014 Evict oldest snapshots until total size \u2264 cap (default 5GB; override via OLAM_SNAPSHOT_MAX_BYTES)
 - \`olam get\` \u2014 Print the active substrate
+- \`olam graph\` \u2014 Query the cross-repo graph: locate a symbol, its relationships, or browse a repo (POST /v1/graph)
 - \`olam hermes\` \u2014 Hermes integration commands
 - \`olam host-cp\` \u2014 Manage the Olam host control plane container
 - \`olam implode\` \u2014 Destroy ALL local olam install and configs (dry-run by default)
@@ -31418,6 +31633,7 @@ Top-level commands (run \`olam <command> --help\` for flags and subcommands):
 - \`olam inspect\` \u2014 Diagnose warm-create cache hits/misses for a workspace (read-only; mutates nothing)
 - \`olam install\` \u2014 Pick an archetype preset for this Olam install
 - \`olam install-hook\` \u2014 Install kg-service hook (idempotent). --for hermes targets ~/.hermes/; default targets .claude/settings.json
+- \`olam install-model-router\` \u2014 Deploy the model-router.py UserPromptSubmit hook script to ~/.claude/hooks/ (idempotent; auto-run by
 - \`olam issue-anthropic-token\` \u2014 Mint a new Anthropic proxy token via the remote auth-worker (g4)
 - \`olam keys\` \u2014 Manage LLM API keys stored at ~/.olam/keys.yaml
 - \`olam kg\` \u2014 Knowledge-graph operations (kg-service container)
@@ -31472,7 +31688,7 @@ Top-level commands (run \`olam <command> --help\` for flags and subcommands):
 - \`olam substrate\` \u2014 Manage deployment substrate (beta)
 - \`olam sync\` \u2014 Sync registered skill sources to ~/.claude/
 - \`olam tls-install\` \u2014 Provision a locally-trusted TLS cert (mkcert) for the Traefik IngressRoute
-- \`olam uninstall\` \u2014 Remove /10x: chain skill symlinks from ~/.claude/skills (preserves user-authored skills + non-chain skill sources)
+- \`olam uninstall\` \u2014 Remove /100x: chain skill symlinks from ~/.claude/skills (preserves user-authored skills + non-chain skill sources)
 - \`olam uninstall-hook\` \u2014 Remove kg-service PreToolUse hook from .claude/settings.json (sentinel-matched; surgical)
 - \`olam unset-prefix\` \u2014 Remove the deploy prefix from a registered skill source (reverts to canonical deploy names)
 - \`olam unset-prefix-scope\` \u2014 Remove the prefix-scope override from a registered skill source (reverts to default: both skill and agent are renamed)
@@ -31678,12 +31894,12 @@ async function runRepl(deps = {}) {
     closed = true;
     onClose?.();
   });
-  const ask = () => new Promise((resolve30) => {
-    if (closed) return resolve30(null);
-    onClose = () => resolve30(null);
+  const ask = () => new Promise((resolve31) => {
+    if (closed) return resolve31(null);
+    onClose = () => resolve31(null);
     rl.question(pc14.cyan("olam ask> "), (line) => {
       onClose = null;
-      resolve30(line);
+      resolve31(line);
     });
   });
   try {
@@ -32221,15 +32437,15 @@ var AGENTMEMORY_LOCAL_URL = "http://host.docker.internal:3111";
 var HOST_CP_URL = "http://127.0.0.1:19000";
 async function readHostCpTokenForCreate() {
   try {
-    const { default: fs107 } = await import("node:fs");
+    const { default: fs108 } = await import("node:fs");
     const { default: os60 } = await import("node:os");
     const { default: path106 } = await import("node:path");
     const tp = path106.join(
       process.env.OLAM_HOME ?? path106.join(os60.homedir(), ".olam"),
       "host-cp.token"
     );
-    if (!fs107.existsSync(tp)) return null;
-    return fs107.readFileSync(tp, "utf-8").trim();
+    if (!fs108.existsSync(tp)) return null;
+    return fs108.readFileSync(tp, "utf-8").trim();
   } catch {
     return null;
   }
@@ -32241,7 +32457,7 @@ function registerCreate(program2) {
   ).option("--devbox-image <ref>", "Override the default devbox image (full registry/name:tag or @sha256: ref)").option("--allow-custom-registry", "Allow --devbox-image refs outside ghcr.io/pleri/* (logs a warning)").option("--runbook <name>", "Named runbook profile from ~/.olam/config.json").option(
     "--claude-home <id-or-path>",
     "Use a per-world Claude Code HOME (multi-account isolation; see docs/decisions/045-claude-home-override.md)"
-  ).action(async (opts) => {
+  ).option("--json", "Emit machine-readable JSON on success (suppresses interactive hints)").action(async (opts) => {
     const { resolveDevboxImageOverride: resolveDevboxImageOverride2, decideAllowlist: decideAllowlist2 } = await Promise.resolve().then(() => (init_registry_allowlist(), registry_allowlist_exports));
     const overrideRef = resolveDevboxImageOverride2(opts.devboxImage);
     if (overrideRef) {
@@ -32729,12 +32945,12 @@ function defaultNameFromPrompt(prompt) {
 }
 async function readHostCpToken3() {
   try {
-    const { default: fs107 } = await import("node:fs");
+    const { default: fs108 } = await import("node:fs");
     const { default: os60 } = await import("node:os");
     const { default: path106 } = await import("node:path");
     const tp = path106.join(os60.homedir(), ".olam", "host-cp.token");
-    if (!fs107.existsSync(tp)) return null;
-    const raw = fs107.readFileSync(tp, "utf-8").trim();
+    if (!fs108.existsSync(tp)) return null;
+    const raw = fs108.readFileSync(tp, "utf-8").trim();
     return raw.length > 0 ? raw : null;
   } catch {
     return null;
@@ -33108,7 +33324,7 @@ function parseRuntimeStatus(raw) {
     last_event_age_seconds
   };
 }
-var fetchWorldRuntimeStatus = (worldId, token) => new Promise((resolve30) => {
+var fetchWorldRuntimeStatus = (worldId, token) => new Promise((resolve31) => {
   const opts = {
     host: "127.0.0.1",
     port: HOST_CP_PORT2,
@@ -33120,7 +33336,7 @@ var fetchWorldRuntimeStatus = (worldId, token) => new Promise((resolve30) => {
   const req = http3.request(opts, (res) => {
     if (res.statusCode !== 200) {
       res.resume();
-      return resolve30(null);
+      return resolve31(null);
     }
     let body = "";
     res.setEncoding("utf-8");
@@ -33130,17 +33346,17 @@ var fetchWorldRuntimeStatus = (worldId, token) => new Promise((resolve30) => {
     res.on("end", () => {
       try {
         const parsed = parseRuntimeStatus(JSON.parse(body));
-        resolve30(parsed);
+        resolve31(parsed);
       } catch {
-        resolve30(null);
+        resolve31(null);
       }
     });
-    res.on("error", () => resolve30(null));
+    res.on("error", () => resolve31(null));
   });
-  req.on("error", () => resolve30(null));
+  req.on("error", () => resolve31(null));
   req.on("timeout", () => {
     req.destroy();
-    resolve30(null);
+    resolve31(null);
   });
   req.end();
 });
@@ -33196,7 +33412,7 @@ async function getMachineStatus(_probe, _loadCtx, _readToken) {
   };
 }
 function registerStatus(program2) {
-  program2.command("status").description("Show machine status, or world details when a world ID is given").argument("[world]", "World ID \u2014 omit to show machine status").option("--json", "Output as JSON").option("--pretty", "Render world status as a human-readable table (engine-aware view)").action(async (worldId, opts) => {
+  program2.command("status").description("Show machine status, or world details when a world ID is given").argument("[world]", "World ID \u2014 omit to show machine status").option("--json", "Output as JSON").action(async (worldId, opts) => {
     if (!worldId) {
       const ms = await getMachineStatus();
       if (opts.json) {
@@ -33330,12 +33546,12 @@ async function readlineConfirm(world) {
 
 `
   );
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     rl.question(
       `Destroy ${pc20.bold(world.name)}? This cannot be undone. [y/N] `,
       (answer) => {
         rl.close();
-        resolve30(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+        resolve31(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
       }
     );
   });
@@ -33690,14 +33906,14 @@ function printTable(entries) {
 async function confirmInteractive() {
   process.stdout.write("  Type `yes` to proceed: ");
   const buf = [];
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     const onData = (chunk) => {
       buf.push(chunk);
       if (Buffer.concat(buf).toString("utf-8").includes("\n")) {
         process.stdin.removeListener("data", onData);
         process.stdin.pause();
         const answer = Buffer.concat(buf).toString("utf-8").trim();
-        resolve30(answer.toLowerCase() === "yes");
+        resolve31(answer.toLowerCase() === "yes");
       }
     };
     process.stdin.resume();
@@ -39893,10 +40109,10 @@ async function confirm2(message) {
   if (!process.stdin.isTTY) return true;
   const { createInterface: createInterface12 } = await import("node:readline");
   const rl = createInterface12({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     rl.question(`${message} [y/N] `, (answer) => {
       rl.close();
-      resolve30(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      resolve31(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
     });
   });
 }
@@ -41140,7 +41356,15 @@ function registerPs(program2) {
       process.exitCode = 1;
       return;
     }
-    const sortKey = ["cpu", "mem", "pid"].includes(opts.sort) ? opts.sort : "cpu";
+    const VALID_SORT_KEYS = ["cpu", "mem", "pid"];
+    if (!VALID_SORT_KEYS.includes(opts.sort)) {
+      printError(
+        `Invalid --sort key "${opts.sort}". Valid values: ${VALID_SORT_KEYS.join(", ")}.`
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const sortKey = opts.sort;
     const containerName = `olam-${worldId}-devbox`;
     let watchInterval;
     function fetchAndPrint() {
@@ -41880,7 +42104,7 @@ async function refreshWorld(worldId, portOffset, standaloneDir, opts) {
   return { worldId, ok: true };
 }
 function registerRefresh(program2) {
-  program2.command("refresh").description("Hot-refresh a running world's per-world CP from the local checkout").argument("[world]", "World ID").option("--all", "Refresh every running world sequentially (overrides positional arg)").option("--no-restart", "Copy files but skip CP restart (for debugging)").option("--skip-build", "Skip the prerequisite server.mjs presence check").action(async (worldId, opts) => {
+  program2.command("refresh").description("Hot-refresh a running world's per-world container-CP bundle (packages/control-plane/standalone/ \u2014 legacy per-world CP surface)").argument("[world]", "World ID").option("--all", "Refresh every running world sequentially (overrides positional arg)").option("--no-restart", "Copy files but skip CP restart (for debugging)").option("--skip-build", "Skip the prerequisite server.mjs presence check").action(async (worldId, opts) => {
     if (!opts.all && !worldId) {
       printError("Specify a world ID or use --all to refresh all running worlds.");
       process.exitCode = 1;
@@ -42566,7 +42790,7 @@ async function runPeripheralProbes(peripheral, startPosition, kubectlContext, wr
   })();
   rows.push({ name: `${peripheral.name} ready`, result: reachableResult, position: startPosition });
   const pfLivenessResult = await (async () => {
-    return new Promise((resolve30) => {
+    return new Promise((resolve31) => {
       const socket = new net4.Socket();
       let done = false;
       const finish = (alive) => {
@@ -42574,9 +42798,9 @@ async function runPeripheralProbes(peripheral, startPosition, kubectlContext, wr
         done = true;
         socket.destroy();
         if (alive) {
-          resolve30({ ok: true, message: `${peripheral.name} port-forward live on :${peripheral.port}` });
+          resolve31({ ok: true, message: `${peripheral.name} port-forward live on :${peripheral.port}` });
         } else {
-          resolve30({
+          resolve31({
             ok: true,
             warn: true,
             message: `${peripheral.name} port-forward not live on :${peripheral.port}`,
@@ -43804,8 +44028,8 @@ function registerCompletion(program2) {
 init_cli_version();
 init_health_probes();
 import { spawn as spawn8, spawnSync as spawnSync29 } from "node:child_process";
-import { existsSync as existsSync90, readFileSync as readFileSync78 } from "node:fs";
-import { homedir as homedir53 } from "node:os";
+import { existsSync as existsSync92, readFileSync as readFileSync80 } from "node:fs";
+import { homedir as homedir54 } from "node:os";
 import path84 from "node:path";
 import { createInterface as createInterface5 } from "node:readline";
 
@@ -44052,9 +44276,9 @@ async function pickSkillSourcePhase(opts, deps) {
 }
 
 // src/commands/setup-phase-5b-project-sweep.ts
-import { homedir as homedir50 } from "node:os";
+import { homedir as homedir51 } from "node:os";
 import * as path82 from "node:path";
-import * as fs82 from "node:fs";
+import * as fs83 from "node:fs";
 async function loadWalkFn() {
   const m = await Promise.resolve().then(() => (init_project_sweep(), project_sweep_exports));
   return m.walkProjectRoot;
@@ -44085,9 +44309,9 @@ async function runProjectSweepPhase(opts, deps, sweepDeps = {}) {
   if (opts.skipProjectSweep) {
     return { ok: true, skipped: true, message: "skipped via --skip-project-sweep" };
   }
-  const home = deps.home ?? homedir50();
+  const home = deps.home ?? homedir51();
   const projectsRoot = opts.projects ?? path82.join(home, "Projects");
-  const existsSyncFn = sweepDeps.existsSync ?? fs82.existsSync;
+  const existsSyncFn = sweepDeps.existsSync ?? fs83.existsSync;
   if (!existsSyncFn(projectsRoot)) {
     return {
       ok: true,
@@ -44188,7 +44412,7 @@ async function runProjectSweepPhase(opts, deps, sweepDeps = {}) {
 }
 
 // src/commands/setup-phase-8-kg-hook.ts
-import * as fs83 from "node:fs";
+import * as fs84 from "node:fs";
 import * as path83 from "node:path";
 import * as os47 from "node:os";
 async function loadMergeHookFn() {
@@ -44218,7 +44442,7 @@ async function runKgHookPhase(opts, _deps, kgDeps = {}) {
       message: `dry-run: would install KG hook into ${settingsPath}`
     };
   }
-  const mkdirFn = kgDeps.mkdirSync ?? ((p, o) => fs83.mkdirSync(p, o));
+  const mkdirFn = kgDeps.mkdirSync ?? ((p, o) => fs84.mkdirSync(p, o));
   try {
     mkdirFn(path83.dirname(settingsPath), { recursive: true });
   } catch (err) {
@@ -44306,10 +44530,10 @@ var NEXT_STEPS_DOCS_KUBERNETES = [
   "https://github.com/pleri/olam/blob/main/docs/architecture/config-spec.md      \u2014 workspace .olam/config.yaml schema",
   "https://github.com/pleri/olam/blob/main/docs/k8s/SETUP.md                     \u2014 k3d operator guide"
 ];
-var defaultSpawn2 = (cmd, args) => new Promise((resolve30) => {
+var defaultSpawn2 = (cmd, args) => new Promise((resolve31) => {
   const child = spawn8(cmd, [...args], { stdio: "inherit" });
-  child.on("exit", (code) => resolve30({ status: code }));
-  child.on("error", () => resolve30({ status: 1 }));
+  child.on("exit", (code) => resolve31({ status: code }));
+  child.on("error", () => resolve31({ status: 1 }));
 });
 var defaultPrompt = (question, defaultYes) => {
   if (!process.stdin.isTTY) {
@@ -44319,18 +44543,18 @@ var defaultPrompt = (question, defaultYes) => {
     );
     return Promise.resolve(defaultYes);
   }
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     const rl = createInterface5({ input: process.stdin, output: process.stdout });
     const suffix = defaultYes ? " [Y/n]: " : " [y/N]: ";
     rl.question(`${question}${suffix}`, (answer) => {
       rl.close();
       const t = answer.trim().toLowerCase();
-      if (t === "") resolve30(defaultYes);
-      else if (t === "y" || t === "yes") resolve30(true);
-      else if (t === "n" || t === "no") resolve30(false);
-      else resolve30(defaultYes);
+      if (t === "") resolve31(defaultYes);
+      else if (t === "y" || t === "yes") resolve31(true);
+      else if (t === "n" || t === "no") resolve31(false);
+      else resolve31(defaultYes);
     });
-    rl.on("close", () => resolve30(defaultYes));
+    rl.on("close", () => resolve31(defaultYes));
   });
 };
 var CLUSTER_NAME_RE = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
@@ -44350,9 +44574,9 @@ function resolveSubstrate(opts, deps) {
   if (opts.substrate === "kubernetes") return "kubernetes";
   if (opts.substrate === "docker") return "docker";
   const configPath = deps.configPath ?? OLAM_CONFIG_PATH;
-  if (existsSync90(configPath)) {
+  if (existsSync92(configPath)) {
     try {
-      const raw = readFileSync78(configPath, "utf8");
+      const raw = readFileSync80(configPath, "utf8");
       const parsed = JSON.parse(raw);
       const host = parsed.host;
       if (host?.substrate === "kubernetes") return "kubernetes";
@@ -44419,9 +44643,9 @@ async function phase0SubstratePicker(opts, deps) {
     return { ok: true, skipped: true, message: "skipped via --skip-substrate-picker" };
   }
   const configPath = deps.configPath ?? OLAM_CONFIG_PATH;
-  if (existsSync90(configPath)) {
+  if (existsSync92(configPath)) {
     try {
-      const raw = readFileSync78(configPath, "utf8");
+      const raw = readFileSync80(configPath, "utf8");
       const parsed = JSON.parse(raw);
       const host = parsed.host;
       if (host?.substrate !== void 0 && host?.preferred_runtime !== void 0) {
@@ -44471,9 +44695,9 @@ async function phase0SubstratePicker(opts, deps) {
   const choice = SUBSTRATE_CHOICES[Number(pickedIndex)] ?? DEFAULT_SUBSTRATE_CHOICE;
   if (choice.requirePinnedContext) {
     let hasPinnedContext = false;
-    if (existsSync90(configPath)) {
+    if (existsSync92(configPath)) {
       try {
-        const raw = readFileSync78(configPath, "utf8");
+        const raw = readFileSync80(configPath, "utf8");
         const parsed = JSON.parse(raw);
         const host = parsed.host;
         hasPinnedContext = typeof host?.kubectl_context_pinned === "string" && host.kubectl_context_pinned.length > 0;
@@ -44630,7 +44854,7 @@ async function phase1SystemCheck(substrate, deps) {
       };
     }
     const platform2 = String(deps.osPlatform ?? process.platform);
-    const home = deps.home ?? homedir53();
+    const home = deps.home ?? homedir54();
     const colimaLint = probeColimaKubernetesEnabled({ platform: platform2, home });
     if (colimaLint.ok && "warn" in colimaLint && colimaLint.warn === true) {
       const lintWithWarn = colimaLint;
@@ -44769,8 +44993,8 @@ async function phase2_5ProvisionCluster(substrate, clusterName, opts, deps, reus
   process.stdout.write(`Creating k3d cluster ${clusterName}...
 `);
   const volumes = [];
-  const ghConfigDir = `${homedir53()}/.config/gh`;
-  if (existsSync90(ghConfigDir)) {
+  const ghConfigDir = `${homedir54()}/.config/gh`;
+  if (existsSync92(ghConfigDir)) {
     volumes.push("--volume", `${ghConfigDir}:/host/.config/gh`);
   } else {
     process.stdout.write(
@@ -44779,7 +45003,7 @@ async function phase2_5ProvisionCluster(substrate, clusterName, opts, deps, reus
     );
   }
   if (opts.hostCpDevPath) {
-    if (!existsSync90(opts.hostCpDevPath)) {
+    if (!existsSync92(opts.hostCpDevPath)) {
       return {
         ok: false,
         message: `--host-cp-dev-path ${opts.hostCpDevPath} does not exist`,
@@ -44944,7 +45168,7 @@ async function phase3_5K3dHttpsBootstrap(substrate, opts, _deps) {
   const result = await ensureTlsInstalled();
   let hostsWarning = "";
   try {
-    const hostsBody = readFileSync78("/etc/hosts", "utf-8");
+    const hostsBody = readFileSync80("/etc/hosts", "utf-8");
     if (!/^[^#\n]*\bolam\.local\b/m.test(hostsBody)) {
       hostsWarning = " Add to /etc/hosts:  echo '127.0.0.1 olam.local' | sudo tee -a /etc/hosts";
     }
@@ -44970,7 +45194,7 @@ async function phase4ShellInit(opts, deps) {
   if (opts.skipShellInit) {
     return { ok: true, skipped: true, message: "skipped via --skip-shell-init" };
   }
-  const home = deps.home ?? homedir53();
+  const home = deps.home ?? homedir54();
   const shellEnv = deps.shellEnv ?? process.env.SHELL;
   const rcPath = resolveShellRc(home, shellEnv);
   if (rcPath === null) {
@@ -45484,24 +45708,24 @@ function registerSetupLinuxGate(program2) {
 }
 
 // src/commands/update.ts
-import * as fs86 from "node:fs";
+import * as fs87 from "node:fs";
 import * as os49 from "node:os";
 import * as path87 from "node:path";
 import { execSync as execSync15 } from "node:child_process";
 import pc33 from "picocolors";
 
 // src/lib/symlink-reconcile.ts
-import * as fs84 from "node:fs";
+import * as fs85 from "node:fs";
 import * as path85 from "node:path";
 var realFs = {
-  readdirSync: (p) => fs84.readdirSync(p),
-  existsSync: (p) => fs84.existsSync(p),
-  lstatSync: (p) => fs84.lstatSync(p),
-  readlinkSync: (p) => fs84.readlinkSync(p),
-  symlinkSync: (t, l) => fs84.symlinkSync(t, l),
-  unlinkSync: (p) => fs84.unlinkSync(p),
+  readdirSync: (p) => fs85.readdirSync(p),
+  existsSync: (p) => fs85.existsSync(p),
+  lstatSync: (p) => fs85.lstatSync(p),
+  readlinkSync: (p) => fs85.readlinkSync(p),
+  symlinkSync: (t, l) => fs85.symlinkSync(t, l),
+  unlinkSync: (p) => fs85.unlinkSync(p),
   mkdirSync: (p, o) => {
-    fs84.mkdirSync(p, o);
+    fs85.mkdirSync(p, o);
   }
 };
 function reconcileSkillSymlinks(npmSkillsDir, claudeSkillsDir2, _fs = realFs) {
@@ -45595,22 +45819,22 @@ function getCurrentVersion(_exec = defaultExec) {
 }
 function readLastStable(file = LAST_STABLE_FILE) {
   try {
-    const v = fs86.readFileSync(file, "utf-8").trim();
+    const v = fs87.readFileSync(file, "utf-8").trim();
     return v || null;
   } catch {
     return null;
   }
 }
 function writeLastStable(version, file = LAST_STABLE_FILE) {
-  fs86.mkdirSync(path87.dirname(file), { recursive: true });
-  fs86.writeFileSync(file, version, { mode: 420 });
+  fs87.mkdirSync(path87.dirname(file), { recursive: true });
+  fs87.writeFileSync(file, version, { mode: 420 });
 }
 function logUpdateFailure(stderr) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
   const logFile = path87.join(LOG_DIR2, `update-${ts}.log`);
   try {
-    fs86.mkdirSync(LOG_DIR2, { recursive: true });
-    fs86.appendFileSync(logFile, `[update-failure ${(/* @__PURE__ */ new Date()).toISOString()}]
+    fs87.mkdirSync(LOG_DIR2, { recursive: true });
+    fs87.appendFileSync(logFile, `[update-failure ${(/* @__PURE__ */ new Date()).toISOString()}]
 ${stderr}
 `, "utf-8");
   } catch {
@@ -45831,7 +46055,7 @@ function registerBegin(program2) {
 // src/commands/config.ts
 init_global_config();
 init_store2();
-import * as fs87 from "node:fs";
+import * as fs88 from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
 var _require4 = createRequire4(import.meta.url);
 var { parse: parseWithMap } = _require4("json-source-map");
@@ -45848,14 +46072,14 @@ function registerConfig(program2) {
   const config = program2.command("config").description("Manage global olam configuration");
   config.command("validate [path]").description("Validate ~/.olam/config.json (or a custom path) against the schema").action((filePath) => {
     const resolvedPath = filePath ?? globalConfigPath();
-    if (!fs87.existsSync(resolvedPath)) {
+    if (!fs88.existsSync(resolvedPath)) {
       process.stderr.write(`config file not found: ${resolvedPath}
 `);
       process.exit(1);
     }
     let raw;
     try {
-      raw = fs87.readFileSync(resolvedPath, "utf-8");
+      raw = fs88.readFileSync(resolvedPath, "utf-8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       process.stderr.write(`cannot read ${resolvedPath}: ${msg}
@@ -46303,9 +46527,9 @@ import * as readline3 from "node:readline";
 import pc37 from "picocolors";
 
 // src/commands/flywheel/install-shims.ts
-import { copyFileSync as copyFileSync9, existsSync as existsSync94, mkdirSync as mkdirSync56, readFileSync as readFileSync82, writeFileSync as writeFileSync48 } from "node:fs";
-import { homedir as homedir56 } from "node:os";
-import { dirname as dirname52, join as join96 } from "node:path";
+import { copyFileSync as copyFileSync9, existsSync as existsSync96, mkdirSync as mkdirSync57, readFileSync as readFileSync84, writeFileSync as writeFileSync50 } from "node:fs";
+import { homedir as homedir57 } from "node:os";
+import { dirname as dirname53, join as join97 } from "node:path";
 
 // src/lib/shim-generator.ts
 var SHIM_SPECS = Object.freeze([
@@ -46368,7 +46592,7 @@ ${argsBlock}
 // src/commands/flywheel/install-shims.ts
 var SHIM_HEADER_MARKER = "# AUTO-GENERATED by `olam flywheel install-shims`";
 function refreshShims(opts = {}) {
-  const targetDir = opts.targetDir ?? join96(homedir56(), ".claude", "scripts");
+  const targetDir = opts.targetDir ?? join97(homedir57(), ".claude", "scripts");
   const results = [];
   let written = 0;
   let overwritten = 0;
@@ -46398,22 +46622,22 @@ function isOlamGeneratedShim(text) {
   return text.includes(SHIM_HEADER_MARKER);
 }
 function installOne(spec, targetDir, opts) {
-  const targetPath = join96(targetDir, spec.basename);
+  const targetPath = join97(targetDir, spec.basename);
   const newContent = generateShim(spec);
-  if (!existsSync94(targetPath)) {
+  if (!existsSync96(targetPath)) {
     if (opts.dryRun !== true) {
-      mkdirSync56(dirname52(targetPath), { recursive: true });
-      writeFileSync48(targetPath, newContent, { mode: 493 });
+      mkdirSync57(dirname53(targetPath), { recursive: true });
+      writeFileSync50(targetPath, newContent, { mode: 493 });
     }
     return { basename: spec.basename, action: "written", targetPath };
   }
-  const existing = readFileSync82(targetPath, "utf8");
+  const existing = readFileSync84(targetPath, "utf8");
   if (existing === newContent) {
     return { basename: spec.basename, action: "unchanged", targetPath };
   }
   if (isOlamGeneratedShim(existing)) {
     if (opts.dryRun !== true) {
-      writeFileSync48(targetPath, newContent, { mode: 493 });
+      writeFileSync50(targetPath, newContent, { mode: 493 });
     }
     return { basename: spec.basename, action: "overwritten", targetPath };
   }
@@ -46421,7 +46645,7 @@ function installOne(spec, targetDir, opts) {
     const backupPath = `${targetPath}.shim-backup-${Math.floor(Date.now() / 1e3)}`;
     if (opts.dryRun !== true) {
       copyFileSync9(targetPath, backupPath);
-      writeFileSync48(targetPath, newContent, { mode: 493 });
+      writeFileSync50(targetPath, newContent, { mode: 493 });
     }
     return { basename: spec.basename, action: "overwritten", targetPath, backupPath };
   }
@@ -46429,7 +46653,7 @@ function installOne(spec, targetDir, opts) {
 }
 function registerFlywheelInstallShims(parent) {
   parent.command("install-shims").description("Install backwards-compat bash shims under ~/.claude/scripts/ that delegate to olam flywheel <subcmd>").option("--force", "overwrite existing non-shim files (backs them up to .shim-backup-<ts>)").option("--dry-run", "preview which shims would be written without modifying disk").option("--target-dir <path>", "override target directory (default: ~/.claude/scripts/); for tests").action((opts) => {
-    const targetDir = opts.targetDir ?? join96(homedir56(), ".claude", "scripts");
+    const targetDir = opts.targetDir ?? join97(homedir57(), ".claude", "scripts");
     const summary2 = refreshShims(opts);
     const lines = [];
     const dryRunSuffix = opts.dryRun === true ? " (dry-run)" : "";
@@ -46482,7 +46706,7 @@ async function decideTrust(opts) {
   return { granted: !denied, method: "interactive" };
 }
 function defaultTrustPrompt(gitUrl) {
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
     process.stdout.write(
       `${pc37.yellow("Trust gate:")} register "${gitUrl}" as a skill source?
@@ -46492,12 +46716,12 @@ Trust this source? ${pc37.dim("[Y/n] ")}`
     );
     rl.question("", (a) => {
       rl.close();
-      resolve30(a);
+      resolve31(a);
     });
   });
 }
 function defaultSourcePrefixPrompt(input2) {
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
     const cfg = input2.newConfig;
     const prefixLabel = cfg.prefix !== void 0 ? `'${cfg.prefix}:'` : "(no prefix)";
@@ -46509,12 +46733,12 @@ Adopt for this host? ${pc37.dim("[Y/n] ")}`
     );
     rl.question("", (a) => {
       rl.close();
-      resolve30(!/^n(o)?$/i.test(a.trim()));
+      resolve31(!/^n(o)?$/i.test(a.trim()));
     });
   });
 }
 function defaultPostAddPrompt(input2) {
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
     process.stdout.write(`
 ${pc37.bold("Sync now?")} ${pc37.dim("[Y/n] ")}`);
@@ -46522,7 +46746,7 @@ ${pc37.bold("Sync now?")} ${pc37.dim("[Y/n] ")}`);
       const sync = !/^n(o)?$/i.test(syncAnswer.trim());
       if (input2.hookAlreadyInstalled) {
         rl.close();
-        resolve30({ syncNow: sync, installHook: false });
+        resolve31({ syncNow: sync, installHook: false });
         return;
       }
       process.stdout.write(
@@ -46531,7 +46755,7 @@ ${pc37.bold("Sync now?")} ${pc37.dim("[Y/n] ")}`);
       rl.question("", (hookAnswer) => {
         rl.close();
         const installHook = !/^n(o)?$/i.test(hookAnswer.trim());
-        resolve30({ syncNow: sync, installHook });
+        resolve31({ syncNow: sync, installHook });
       });
     });
   });
@@ -47188,7 +47412,7 @@ function registerSkillsSource(program2) {
 // src/commands/skills.ts
 init_skill_sources();
 init_output();
-import * as fs88 from "node:fs";
+import * as fs89 from "node:fs";
 import * as os50 from "node:os";
 import * as path88 from "node:path";
 import * as readline4 from "node:readline";
@@ -47199,18 +47423,18 @@ init_markdown_merger();
 init_file_lock();
 import {
   copyFileSync as copyFileSync10,
-  existsSync as existsSync95,
+  existsSync as existsSync97,
   lstatSync as lstatSync8,
-  mkdirSync as mkdirSync57,
+  mkdirSync as mkdirSync58,
   readdirSync as readdirSync28,
-  readFileSync as readFileSync83,
+  readFileSync as readFileSync85,
   readlinkSync as readlinkSync4,
   rmSync as rmSync11,
   statSync as statSync28,
-  writeFileSync as writeFileSync49
+  writeFileSync as writeFileSync51
 } from "node:fs";
-import { homedir as homedir57 } from "node:os";
-import { basename as basename8, dirname as dirname53, isAbsolute as isAbsolute4, join as join97, relative as relative5, resolve as resolve23 } from "node:path";
+import { homedir as homedir58 } from "node:os";
+import { basename as basename8, dirname as dirname54, isAbsolute as isAbsolute4, join as join98, relative as relative5, resolve as resolve24 } from "node:path";
 
 // src/commands/flywheel/sanitize-persona-output.ts
 var FORBIDDEN_HEADERS = [
@@ -47272,23 +47496,23 @@ function registerFlywheelSanitizePersonaOutput(parent) {
 
 // src/lib/skills-apply-overlays.ts
 function claudeRoot(opts) {
-  return opts.claudeDir ?? opts.fixtureRoot ?? join97(homedir57(), ".claude");
+  return opts.claudeDir ?? opts.fixtureRoot ?? join98(homedir58(), ".claude");
 }
 function ensureRealDir(p) {
-  if (!existsSync95(p)) {
-    mkdirSync57(p, { recursive: true });
+  if (!existsSync97(p)) {
+    mkdirSync58(p, { recursive: true });
     return;
   }
   const stat = lstatSync8(p);
   if (stat.isSymbolicLink()) {
     const targetRaw = readlinkSync4(p);
-    const target = isAbsolute4(targetRaw) ? targetRaw : resolve23(dirname53(p), targetRaw);
+    const target = isAbsolute4(targetRaw) ? targetRaw : resolve24(dirname54(p), targetRaw);
     rmSync11(p);
-    mkdirSync57(p, { recursive: true });
-    if (existsSync95(target) && statSync28(target).isDirectory()) {
+    mkdirSync58(p, { recursive: true });
+    if (existsSync97(target) && statSync28(target).isDirectory()) {
       for (const entry of readdirSync28(target)) {
-        const src = join97(target, entry);
-        const dest = join97(p, entry);
+        const src = join98(target, entry);
+        const dest = join98(p, entry);
         const srcStat = lstatSync8(src);
         if (srcStat.isDirectory()) {
           try {
@@ -47310,8 +47534,8 @@ function postMergeSanitize(mergedText, label) {
   return { ok: false, reason: `[post-merge-sanitize] ${label} merged output failed sanitizer: ${result.reason}` };
 }
 function mergeOne(upstreamPath, overlayPath, destPath2, label, dryRun, messages) {
-  const upstreamText = readFileSync83(upstreamPath, "utf8");
-  const overlayText = readFileSync83(overlayPath, "utf8");
+  const upstreamText = readFileSync85(upstreamPath, "utf8");
+  const overlayText = readFileSync85(overlayPath, "utf8");
   const result = mergeMarkdown(upstreamText, overlayText, label, upstreamPath, overlayPath);
   if ("error" in result) {
     messages.push(`ERROR ${result.error.reason}`);
@@ -47323,15 +47547,15 @@ function mergeOne(upstreamPath, overlayPath, destPath2, label, dryRun, messages)
     return { ok: false, kind: "sanitize" };
   }
   if (!dryRun) {
-    mkdirSync57(dirname53(destPath2), { recursive: true });
-    writeFileSync49(destPath2, result.merged, "utf8");
+    mkdirSync58(dirname54(destPath2), { recursive: true });
+    writeFileSync51(destPath2, result.merged, "utf8");
   }
   messages.push(`MERGED ${label} \u2192 ${destPath2}${dryRun ? " (dry-run)" : ""}`);
   return { ok: true };
 }
 function isNewAgentOverlay(overlayPath) {
   try {
-    const text = readFileSync83(overlayPath, "utf8");
+    const text = readFileSync85(overlayPath, "utf8");
     const { fm } = parseFrontmatter3(text);
     return fm["overlay-intent"] === "new-agent";
   } catch {
@@ -47340,18 +47564,18 @@ function isNewAgentOverlay(overlayPath) {
 }
 function copyNewAgent(overlayPath, destPath2, label, dryRun, messages) {
   if (!dryRun) {
-    mkdirSync57(dirname53(destPath2), { recursive: true });
+    mkdirSync58(dirname54(destPath2), { recursive: true });
     copyFileSync10(overlayPath, destPath2);
   }
   messages.push(`NEW-AGENT ${label} \u2192 ${destPath2}${dryRun ? " (dry-run)" : ""}`);
 }
 function walkSkillsOverlays(skillsOverridesDir, skillsDir, opts, result) {
-  if (!existsSync95(skillsOverridesDir)) return;
+  if (!existsSync97(skillsOverridesDir)) return;
   for (const skillName of readdirSync28(skillsOverridesDir)) {
-    const overlaySkillDir = join97(skillsOverridesDir, skillName);
+    const overlaySkillDir = join98(skillsOverridesDir, skillName);
     if (!statSync28(overlaySkillDir).isDirectory()) continue;
-    const upstreamSkillDir = join97(skillsDir, skillName);
-    if (!existsSync95(upstreamSkillDir)) {
+    const upstreamSkillDir = join98(skillsDir, skillName);
+    if (!existsSync97(upstreamSkillDir)) {
       result.messages.push(`SKIP ${skillName}: no upstream skill at ${upstreamSkillDir} (skill overlays require an upstream skill dir)`);
       continue;
     }
@@ -47364,7 +47588,7 @@ function walkOverlayTree(overlayRoot, upstreamRoot, labelPrefix, opts, result, i
   while (stack.length > 0) {
     const current = stack.pop();
     for (const entry of readdirSync28(current)) {
-      const overlayPath = join97(current, entry);
+      const overlayPath = join98(current, entry);
       const stat = lstatSync8(overlayPath);
       if (stat.isDirectory()) {
         stack.push(overlayPath);
@@ -47372,17 +47596,17 @@ function walkOverlayTree(overlayRoot, upstreamRoot, labelPrefix, opts, result, i
       }
       if (!stat.isFile() && !stat.isSymbolicLink()) continue;
       const rel = relative5(overlayRoot, overlayPath);
-      const upstreamPath = join97(upstreamRoot, rel);
+      const upstreamPath = join98(upstreamRoot, rel);
       const label = `${labelPrefix} ${rel}`;
       if (!entry.endsWith(".md")) {
         if (!opts.dryRun) {
-          mkdirSync57(dirname53(upstreamPath), { recursive: true });
+          mkdirSync58(dirname54(upstreamPath), { recursive: true });
           copyFileSync10(overlayPath, upstreamPath);
         }
         result.messages.push(`COPY ${label} \u2192 ${upstreamPath}${opts.dryRun === true ? " (dry-run)" : ""}`);
         continue;
       }
-      if (!existsSync95(upstreamPath)) {
+      if (!existsSync97(upstreamPath)) {
         if (isAgentsContext && isNewAgentOverlay(overlayPath)) {
           copyNewAgent(overlayPath, upstreamPath, label, opts.dryRun === true, result.messages);
           result.newAgentsCreated += 1;
@@ -47391,7 +47615,7 @@ function walkOverlayTree(overlayRoot, upstreamRoot, labelPrefix, opts, result, i
           result.renameHalts += 1;
         } else {
           if (!opts.dryRun) {
-            mkdirSync57(dirname53(upstreamPath), { recursive: true });
+            mkdirSync58(dirname54(upstreamPath), { recursive: true });
             copyFileSync10(overlayPath, upstreamPath);
           }
           result.messages.push(`NEW-FILE ${label} \u2192 ${upstreamPath}${opts.dryRun === true ? " (dry-run)" : ""}`);
@@ -47411,16 +47635,16 @@ function walkOverlayTree(overlayRoot, upstreamRoot, labelPrefix, opts, result, i
   }
 }
 function walkAgentsOverlays(agentsOverridesDir, agentsDir, opts, result) {
-  if (!existsSync95(agentsOverridesDir)) return;
+  if (!existsSync97(agentsOverridesDir)) return;
   ensureRealDir(agentsDir);
   walkOverlayTree(agentsOverridesDir, agentsDir, "agent", opts, result, true);
 }
 async function applyOverlays(opts = {}) {
   const root = claudeRoot(opts);
-  const skillsDir = join97(root, "skills");
-  const agentsDir = join97(root, "agents");
-  const skillsOverridesDir = join97(root, "skills.overrides");
-  const agentsOverridesDir = join97(root, "agents.overrides");
+  const skillsDir = join98(root, "skills");
+  const agentsDir = join98(root, "agents");
+  const skillsOverridesDir = join98(root, "skills.overrides");
+  const agentsOverridesDir = join98(root, "agents.overrides");
   const result = {
     rc: 0,
     skillsMerged: 0,
@@ -47463,6 +47687,44 @@ function formatSummary(result) {
   return lines.join("\n") + "\n";
 }
 
+// src/commands/skills-install-model-router.ts
+init_model_router_deploy();
+init_output();
+function registerSkillsInstallModelRouter(skills) {
+  skills.command("install-model-router").description("Deploy the model-router.py UserPromptSubmit hook script to ~/.claude/hooks/ (idempotent; auto-run by `olam skills sync`)").option("--dry-run", "preview the action without writing to disk").option("--target-dir <path>", "override target directory (default: ~/.claude/hooks/); for tests").option("--source-path <path>", "override canonical source path; for tests").action((opts) => {
+    try {
+      const result = deployModelRouterScript({
+        ...opts.sourcePath !== void 0 ? { sourcePath: opts.sourcePath } : {},
+        ...opts.targetDir !== void 0 ? { targetDir: opts.targetDir } : {},
+        ...opts.dryRun !== void 0 ? { dryRun: opts.dryRun } : {}
+      });
+      const dryRunSuffix = opts.dryRun === true ? " (dry-run)" : "";
+      switch (result.action) {
+        case "written":
+          process.stdout.write(`  WRITTEN     ${result.targetPath}${dryRunSuffix}
+`);
+          break;
+        case "unchanged":
+          process.stdout.write(`  UNCHANGED   ${result.targetPath}
+`);
+          break;
+        case "source-missing":
+          printError(
+            `canonical model-router.py source not found \u2014 olam install may be corrupt. Expected at packages/cli/hooks/model-router.py.`
+          );
+          process.exitCode = 2;
+          return;
+      }
+      process.stdout.write(`
+model-router hook script ready at ${result.targetPath}
+`);
+    } catch (err) {
+      printError(`[install-model-router-error] ${err instanceof Error ? err.message : "unknown error"}`);
+      process.exitCode = 2;
+    }
+  });
+}
+
 // src/commands/skills.ts
 function asMessage4(err) {
   return err instanceof Error ? err.message : String(err);
@@ -47470,11 +47732,11 @@ function asMessage4(err) {
 var ATLAS_USER_PICKER_RE = /^[a-z0-9][a-z0-9_-]{0,38}$/;
 function listMemberNames(clonePath) {
   const membersDir = path88.join(clonePath, "members");
-  if (!fs88.existsSync(membersDir)) return [];
+  if (!fs89.existsSync(membersDir)) return [];
   try {
-    return fs88.readdirSync(membersDir).filter((e) => {
+    return fs89.readdirSync(membersDir).filter((e) => {
       try {
-        return fs88.statSync(path88.join(membersDir, e)).isDirectory();
+        return fs89.statSync(path88.join(membersDir, e)).isDirectory();
       } catch {
         return false;
       }
@@ -47490,7 +47752,7 @@ function formatSourcePrefix(cfg) {
   return `${p}${s}`;
 }
 function defaultSourcePrefixSyncPrompt(input2) {
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     const rl = readline4.createInterface({ input: process.stdin, output: process.stdout });
     const newLabel = formatSourcePrefix(input2.newConfig);
     let line;
@@ -47507,16 +47769,16 @@ Accept change? ${pc38.dim("[Y/n] ")}`;
     process.stdout.write(line);
     rl.question("", (a) => {
       rl.close();
-      resolve30(!/^n(o)?$/i.test(a.trim()));
+      resolve31(!/^n(o)?$/i.test(a.trim()));
     });
   });
 }
 function defaultAtlasUserPrompt(question) {
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     const rl = readline4.createInterface({ input: process.stdin, output: process.stdout });
     rl.question(question, (a) => {
       rl.close();
-      resolve30(a);
+      resolve31(a);
     });
   });
 }
@@ -47525,8 +47787,8 @@ async function resolveAtlasUserWithPicker(cliOverride, opts) {
   const ATLAS_USER_RE2 = /^[a-z0-9][a-z0-9_-]{0,38}$/;
   const claudeDirPathForRead = opts?._testClaudeDir ?? (process.env["OLAM_CLAUDE_DIR"] ?? path88.join(os50.homedir(), ".claude"));
   const atlasUserFile = path88.join(claudeDirPathForRead, ".atlas-user");
-  if (fs88.existsSync(atlasUserFile)) {
-    const existing = fs88.readFileSync(atlasUserFile, "utf-8").trim();
+  if (fs89.existsSync(atlasUserFile)) {
+    const existing = fs89.readFileSync(atlasUserFile, "utf-8").trim();
     if (existing.length > 0) {
       if (ATLAS_USER_RE2.test(existing)) {
         return existing;
@@ -47586,8 +47848,8 @@ async function resolveAtlasUserWithPicker(cliOverride, opts) {
     return void 0;
   }
   const claudeDirPath = opts?._testClaudeDir ?? (process.env["OLAM_CLAUDE_DIR"] ?? path88.join(os50.homedir(), ".claude"));
-  fs88.mkdirSync(claudeDirPath, { recursive: true });
-  fs88.writeFileSync(path88.join(claudeDirPath, ".atlas-user"), picked + "\n", "utf8");
+  fs89.mkdirSync(claudeDirPath, { recursive: true });
+  fs89.writeFileSync(path88.join(claudeDirPath, ".atlas-user"), picked + "\n", "utf8");
   process.stdout.write(pc38.green(`\u2713 atlas-user set to "${picked}" (written to ${path88.join(claudeDirPath, ".atlas-user")})
 `));
   return picked;
@@ -47601,13 +47863,13 @@ function listDeployed() {
   const entries = [];
   for (const bucket of ["skills", "agents", "scripts", "rules", "commands"]) {
     const bucketDir = path88.join(dir, bucket);
-    if (!fs88.existsSync(bucketDir)) continue;
-    for (const name of fs88.readdirSync(bucketDir)) {
+    if (!fs89.existsSync(bucketDir)) continue;
+    for (const name of fs89.readdirSync(bucketDir)) {
       const full = path88.join(bucketDir, name);
       try {
-        const stat = fs88.lstatSync(full);
+        const stat = fs89.lstatSync(full);
         if (!stat.isSymbolicLink()) continue;
-        const target = fs88.readlinkSync(full);
+        const target = fs89.readlinkSync(full);
         let sourceId;
         for (const [clonePath, id] of sourcePaths.entries()) {
           if (target.startsWith(clonePath)) {
@@ -47823,17 +48085,18 @@ function registerSkills(program2) {
       process.exitCode = 2;
     }
   });
+  registerSkillsInstallModelRouter(skills);
 }
 
 // src/commands/skills-hook.ts
 init_skill_sources();
 init_output();
-import * as fs89 from "node:fs";
+import * as fs90 from "node:fs";
 function backup(filePath) {
-  if (!fs89.existsSync(filePath)) return null;
+  if (!fs90.existsSync(filePath)) return null;
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const backupPath = `${filePath}.olam-bak.${ts}`;
-  fs89.copyFileSync(filePath, backupPath);
+  fs90.copyFileSync(filePath, backupPath);
   return backupPath;
 }
 function registerSkillsHook(program2) {
@@ -47881,7 +48144,7 @@ function registerSkillsHook(program2) {
           printInfo("olam-skills hook", `not found in ${filePath} \u2014 already uninstalled`);
           if (backupPath) {
             try {
-              fs89.unlinkSync(backupPath);
+              fs90.unlinkSync(backupPath);
             } catch {
             }
           }
@@ -48068,24 +48331,24 @@ init_skill_sources();
 init_merge_settings();
 init_skill_sources();
 init_output();
-import * as fs90 from "node:fs";
+import * as fs91 from "node:fs";
 import * as path89 from "node:path";
 var MIGRATE_FROM_TOOLBOX_COMMAND = "migrate-from-toolbox";
 function asMessage6(err) {
   return err instanceof Error ? err.message : String(err);
 }
 function isOlamSkillsHookPresent(filePath) {
-  if (!fs90.existsSync(filePath)) return false;
+  if (!fs91.existsSync(filePath)) return false;
   try {
-    const raw = fs90.readFileSync(filePath, "utf-8");
+    const raw = fs91.readFileSync(filePath, "utf-8");
     return raw.includes(OLAM_SKILLS_HOOK_SENTINEL);
   } catch {
     return false;
   }
 }
 function uninstallLegacyToolboxSessionStartHook(filePath, toolboxPath) {
-  if (!fs90.existsSync(filePath)) return { removed: 0 };
-  const raw = fs90.readFileSync(filePath, "utf-8");
+  if (!fs91.existsSync(filePath)) return { removed: 0 };
+  const raw = fs91.readFileSync(filePath, "utf-8");
   const settings = raw.trim() ? JSON.parse(raw) : {};
   const ss = settings?.hooks?.SessionStart;
   if (!Array.isArray(ss)) return { removed: 0 };
@@ -48114,7 +48377,7 @@ function uninstallLegacyToolboxSessionStartHook(filePath, toolboxPath) {
     if (otherStages.length === 0) delete next.hooks;
     else delete next.hooks.SessionStart;
   }
-  fs90.writeFileSync(filePath, JSON.stringify(next, null, 2) + "\n");
+  fs91.writeFileSync(filePath, JSON.stringify(next, null, 2) + "\n");
   return { removed };
 }
 function registerSkillsMigrate(program2) {
@@ -48193,7 +48456,7 @@ function registerSkillsMigrate(program2) {
     const scope = opts.scope === "user" ? "user" : "project";
     const olamHookPath = scope === "user" ? settingsFile : path89.join(process.cwd(), ".claude", "settings.json");
     try {
-      fs90.mkdirSync(path89.dirname(olamHookPath), { recursive: true });
+      fs91.mkdirSync(path89.dirname(olamHookPath), { recursive: true });
       const result = mergeHomeSettingsJson(olamHookPath, {
         ensureHook: {
           stage: OLAM_SKILLS_HOOK_STAGE,
@@ -48226,7 +48489,7 @@ function registerSkillsMigrate(program2) {
 // src/commands/skills-migrate-back.ts
 init_skill_sources();
 init_output();
-import * as fs91 from "node:fs";
+import * as fs92 from "node:fs";
 import * as path90 from "node:path";
 var MIGRATE_BACK_TO_TOOLBOX_COMMAND = "migrate-back-to-toolbox";
 function asMessage7(err) {
@@ -48242,9 +48505,9 @@ function restoreSessionStartFromSnapshot(filePath, originalSessionStartHook) {
     return { restored: false };
   }
   let settings;
-  if (fs91.existsSync(filePath)) {
+  if (fs92.existsSync(filePath)) {
     try {
-      const raw = fs91.readFileSync(filePath, "utf-8");
+      const raw = fs92.readFileSync(filePath, "utf-8");
       settings = raw.trim() ? JSON.parse(raw) : {};
     } catch {
       settings = {};
@@ -48260,8 +48523,8 @@ function restoreSessionStartFromSnapshot(filePath, originalSessionStartHook) {
       SessionStart: originalSessionStartHook
     }
   };
-  fs91.mkdirSync(path90.dirname(filePath), { recursive: true });
-  fs91.writeFileSync(filePath, JSON.stringify(next, null, 2) + "\n");
+  fs92.mkdirSync(path90.dirname(filePath), { recursive: true });
+  fs92.writeFileSync(filePath, JSON.stringify(next, null, 2) + "\n");
   return { restored: true };
 }
 function removeOlamManagedSymlinks() {
@@ -48271,15 +48534,15 @@ function removeOlamManagedSymlinks() {
   let removed = 0;
   for (const bucket of ["skills", "agents", "scripts", "rules", "commands"]) {
     const dir = path90.join(claude, bucket);
-    if (!fs91.existsSync(dir)) continue;
-    for (const name of fs91.readdirSync(dir)) {
+    if (!fs92.existsSync(dir)) continue;
+    for (const name of fs92.readdirSync(dir)) {
       const linkPath = path90.join(dir, name);
       try {
-        const stat = fs91.lstatSync(linkPath);
+        const stat = fs92.lstatSync(linkPath);
         if (!stat.isSymbolicLink()) continue;
-        const target = fs91.readlinkSync(linkPath);
+        const target = fs92.readlinkSync(linkPath);
         if (olamClonePaths.some((cp) => target.startsWith(cp))) {
-          fs91.unlinkSync(linkPath);
+          fs92.unlinkSync(linkPath);
           removed += 1;
         }
       } catch {
@@ -48292,18 +48555,18 @@ function restoreToolboxSymlinks(symlinks) {
   let restored = 0;
   for (const { link, target } of symlinks) {
     try {
-      fs91.mkdirSync(path90.dirname(link), { recursive: true });
-      if (fs91.existsSync(link) || (() => {
+      fs92.mkdirSync(path90.dirname(link), { recursive: true });
+      if (fs92.existsSync(link) || (() => {
         try {
-          fs91.lstatSync(link);
+          fs92.lstatSync(link);
           return true;
         } catch {
           return false;
         }
       })()) {
-        fs91.unlinkSync(link);
+        fs92.unlinkSync(link);
       }
-      fs91.symlinkSync(target, link);
+      fs92.symlinkSync(target, link);
       restored += 1;
     } catch {
     }
@@ -48313,8 +48576,8 @@ function restoreToolboxSymlinks(symlinks) {
 function restoreAtlasUserMarker(atlasUser) {
   if (!atlasUser) return false;
   const file = path90.join(claudeDirInternal4(), ".atlas-user");
-  fs91.mkdirSync(path90.dirname(file), { recursive: true });
-  fs91.writeFileSync(file, atlasUser);
+  fs92.mkdirSync(path90.dirname(file), { recursive: true });
+  fs92.writeFileSync(file, atlasUser);
   return true;
 }
 function registerSkillsMigrateBack(program2) {
@@ -48328,7 +48591,7 @@ function registerSkillsMigrateBack(program2) {
     try {
       if (opts.snapshot) {
         snapshotPath = path90.resolve(opts.snapshot);
-        if (!fs91.existsSync(snapshotPath)) {
+        if (!fs92.existsSync(snapshotPath)) {
           printError(`snapshot not found at ${snapshotPath}`);
           process.exitCode = 1;
           return;
@@ -48412,7 +48675,7 @@ init_meta_hooks_migration_snapshot();
 init_trust_audit_log();
 init_atlas_hook_strip();
 init_output();
-import * as fs92 from "node:fs";
+import * as fs93 from "node:fs";
 import * as path91 from "node:path";
 import pc40 from "picocolors";
 var MIGRATE_HOOKS_COMMAND = "migrate-hooks";
@@ -48434,16 +48697,16 @@ function settingsHasOlamMetaSentinel(settings) {
   return false;
 }
 function readSettings2(filePath) {
-  if (!fs92.existsSync(filePath)) return null;
-  const raw = fs92.readFileSync(filePath, "utf-8");
+  if (!fs93.existsSync(filePath)) return null;
+  const raw = fs93.readFileSync(filePath, "utf-8");
   if (raw.trim().length === 0) return {};
   return JSON.parse(raw);
 }
 function writeSettings(filePath, settings) {
-  fs92.mkdirSync(path91.dirname(filePath), { recursive: true });
+  fs93.mkdirSync(path91.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-migrate-hooks-${process.pid}-${Date.now()}`;
-  fs92.writeFileSync(tmp, JSON.stringify(settings, null, 2) + "\n");
-  fs92.renameSync(tmp, filePath);
+  fs93.writeFileSync(tmp, JSON.stringify(settings, null, 2) + "\n");
+  fs93.renameSync(tmp, filePath);
 }
 function printSummary(candidates2, opts) {
   if (candidates2.length === 0) {
@@ -48578,7 +48841,7 @@ function registerSkillsMigrateHooksBack(program2) {
 // src/commands/skills-shadow-backups.ts
 init_skill_sources();
 init_output();
-import * as fs93 from "node:fs";
+import * as fs94 from "node:fs";
 import pc41 from "picocolors";
 function asMessage10(err) {
   return err instanceof Error ? err.message : String(err);
@@ -48661,7 +48924,7 @@ function registerSkillsShadowBackups(program2) {
   });
   sb.command("restore").description("Move a shadow-backup file back to its original path").argument("<path>", "Absolute path to the .shadow-backup-<epoch> file").option("--force", "Overwrite the original path if it already exists").action((p, opts) => {
     try {
-      if (!fs93.existsSync(p)) {
+      if (!fs94.existsSync(p)) {
         printError(`backup file not found: ${p}`);
         process.exitCode = 1;
         return;
@@ -48684,11 +48947,11 @@ function asMessage11(err) {
   return err instanceof Error ? err.message : String(err);
 }
 function defaultDoctorPrompt(question) {
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     const rl = readline5.createInterface({ input: process.stdin, output: process.stdout });
     rl.question(question, (a) => {
       rl.close();
-      resolve30(a);
+      resolve31(a);
     });
   });
 }
@@ -48779,23 +49042,26 @@ function registerSkillsDoctor(program2) {
   });
 }
 
-// src/commands/skills-10x.ts
+// src/commands/skills-100x.ts
 init_skill_sources();
 init_cli_version();
 init_output();
 import { execFileSync as execFileSync17 } from "node:child_process";
-import * as fs94 from "node:fs";
+import * as fs95 from "node:fs";
 import * as path93 from "node:path";
 var CHAIN_SKILL_NAMES = [
-  "10x:brainstorm",
-  "10x:plan-hard",
-  "10x:review-plan",
-  "10x:break-plan",
-  "10x:commit-plan",
-  "10x:execute",
-  "10x:retro",
-  "10x:learn"
+  "100x:brainstorm",
+  "100x:plan-hard",
+  "100x:review-plan",
+  "100x:break-plan",
+  "100x:commit-plan",
+  "100x:execute",
+  "100x:retro",
+  "100x:learn"
 ];
+var PLUGIN_MARKETPLACE = "atlas-builders/atlas-toolbox";
+var PLUGIN_SPEC = "100x@atlas-one";
+var PLUGIN_SCOPES = ["user", "project", "local"];
 function asMessage12(err) {
   return err instanceof Error ? err.message : String(err);
 }
@@ -48808,13 +49074,13 @@ function hasBeadsCli() {
   }
 }
 function hasBeadsProjectInit(cwd) {
-  return fs94.existsSync(path93.join(cwd, ".beads"));
+  return fs95.existsSync(path93.join(cwd, ".beads"));
 }
 function hasBeadsClaudeSetup() {
   const settingsPath = path93.join(claudeDir(), "settings.json");
-  if (!fs94.existsSync(settingsPath)) return false;
+  if (!fs95.existsSync(settingsPath)) return false;
   try {
-    const content = fs94.readFileSync(settingsPath, "utf8");
+    const content = fs95.readFileSync(settingsPath, "utf8");
     return /"command"\s*:\s*"bd\b/.test(content) || /"bd setup\b/.test(content);
   } catch {
     return false;
@@ -48851,6 +49117,37 @@ async function bootstrapBeads(cwd) {
     console.log("beads Claude hooks already installed \u2014 skipping bd setup");
   }
 }
+function normalizeScope(raw) {
+  if (raw === void 0) return "user";
+  if (PLUGIN_SCOPES.includes(raw)) {
+    return raw;
+  }
+  throw new Error(
+    `invalid --scope '${raw}' \u2014 expected one of: ${PLUGIN_SCOPES.join(", ")}`
+  );
+}
+function addPluginMarketplace(scope) {
+  console.log(
+    `claude plugin marketplace add ${PLUGIN_MARKETPLACE} (scope: ${scope})`
+  );
+  try {
+    execFileSync17(
+      "claude",
+      ["plugin", "marketplace", "add", PLUGIN_MARKETPLACE, "--scope", scope],
+      { stdio: "inherit" }
+    );
+  } catch (err) {
+    printWarning(
+      `claude plugin marketplace add returned an error (continuing \u2014 likely already added): ${asMessage12(err)}`
+    );
+  }
+}
+function installPlugin(scope) {
+  console.log(`claude plugin install ${PLUGIN_SPEC} (scope: ${scope})`);
+  execFileSync17("claude", ["plugin", "install", PLUGIN_SPEC, "--scope", scope], {
+    stdio: "inherit"
+  });
+}
 function captureSourceShas() {
   return listSkillSources().map((s) => ({
     id: s.id,
@@ -48880,11 +49177,11 @@ function shortSha(sha) {
 }
 function listInstalledClaudeSkills() {
   const skillsDir = path93.join(claudeDir(), "skills");
-  if (!fs94.existsSync(skillsDir)) return [];
+  if (!fs95.existsSync(skillsDir)) return [];
   try {
-    return fs94.readdirSync(skillsDir).filter((name) => {
+    return fs95.readdirSync(skillsDir).filter((name) => {
       try {
-        const stat = fs94.lstatSync(path93.join(skillsDir, name));
+        const stat = fs95.lstatSync(path93.join(skillsDir, name));
         return stat.isSymbolicLink() || stat.isDirectory();
       } catch {
         return false;
@@ -48897,24 +49194,64 @@ function listInstalledClaudeSkills() {
 function isChainSkill(name) {
   const lower = name.toLowerCase();
   return CHAIN_SKILL_NAMES.some((canonical) => {
-    const slug = canonical.replace(/^10x:/, "");
-    return lower === canonical.toLowerCase() || lower === slug || lower === `10x-${slug}`;
+    const slug = canonical.replace(/^100x:/, "");
+    return lower === canonical.toLowerCase() || lower === slug || lower === `100x-${slug}` || // Legacy pre-rename forms (10x:slug / 10x-slug).
+    lower === `10x:${slug}` || lower === `10x-${slug}`;
   });
 }
-function registerSkills10x(program2) {
-  const skills = program2.commands.find((c) => c.name() === "skills") ?? program2.command("skills").description("Manage skill sources and synchronization");
-  const tenx = skills.command("10x").description(
-    "Manage the /10x: planning chain skills + beads integration"
+function registerSkills100x(program2) {
+  registerTopLevel100x(program2);
+  registerDeprecatedSkills10xAlias(program2);
+}
+function registerTopLevel100x(program2) {
+  const onex = program2.command("100x").description(
+    "Install the /100x: planning chain as a native Claude Code plugin + beads integration"
   );
+  onex.command("install").description(
+    "Install the native Claude Code plugin (claude plugin marketplace add + plugin install) + auto-bootstrap beads (bd init + bd setup claude)."
+  ).option("--no-beads", "Skip beads auto-bootstrap (plugin install only)").option(
+    "--scope <scope>",
+    "Plugin scope passed through to claude (user|project|local)",
+    "user"
+  ).action(async (opts) => {
+    try {
+      const scope = normalizeScope(opts.scope);
+      console.log(
+        "Installing the /100x: chain via the native Claude Code plugin..."
+      );
+      addPluginMarketplace(scope);
+      installPlugin(scope);
+      printSuccess(`Installed plugin ${PLUGIN_SPEC} (scope: ${scope})`);
+      if (opts.beads !== false) {
+        await bootstrapBeads(process.cwd());
+      } else {
+        console.log("--no-beads \u2014 skipping beads auto-bootstrap");
+      }
+      printSuccess("olam 100x install complete");
+    } catch (err) {
+      printError(`Install failed: ${asMessage12(err)}`);
+      process.exitCode = 1;
+    }
+  });
+}
+function registerDeprecatedSkills10xAlias(program2) {
+  const skills = program2.commands.find((c) => c.name() === "skills") ?? program2.command("skills").description("Manage skill sources and synchronization");
+  const tenx = skills.command("10x", { hidden: true }).description(
+    "DEPRECATED \u2014 use `olam 100x install`. Manage the /100x: planning chain skills via syncSkills() + beads."
+  ).hook("preAction", () => {
+    printWarning(
+      "DEPRECATED: `olam skills 10x` \u2014 use `olam 100x install` (native Claude Code plugin) instead."
+    );
+  });
   tenx.command("install").description(
-    "Sync /10x: chain skills from registered sources + auto-bootstrap beads (bd init + bd setup claude). Surfaces source-SHA bumps + shadow-backups for sentinel-versioned upgrade."
+    "Sync /100x: chain skills from registered sources + auto-bootstrap beads (bd init + bd setup claude). Surfaces source-SHA bumps + shadow-backups for sentinel-versioned upgrade."
   ).option("--no-beads", "Skip beads auto-bootstrap (chain skills only)").option(
     "--force",
     "Suppress shadow-backup warning + proceed without operator attention (shadow backups are still created by the sync engine; this flag only suppresses the surface-prominence)"
   ).action(async (opts) => {
     try {
       const preSync = captureSourceShas();
-      console.log("Syncing /10x: chain skills from registered sources...");
+      console.log("Syncing /100x: chain skills from registered sources...");
       const summary2 = await syncSkills({});
       printSuccess(
         `Synced ${summary2.artifactCount} artifact(s) from ${summary2.sourceCount} source(s)`
@@ -48957,43 +49294,43 @@ function registerSkills10x(program2) {
     }
   });
   tenx.command("uninstall").description(
-    "Remove /10x: chain skill symlinks from ~/.claude/skills (preserves user-authored skills + non-chain skill sources)"
+    "Remove /100x: chain skill symlinks from ~/.claude/skills (preserves user-authored skills + non-chain skill sources)"
   ).action(() => {
     const skillsDir = path93.join(claudeDir(), "skills");
-    if (!fs94.existsSync(skillsDir)) {
+    if (!fs95.existsSync(skillsDir)) {
       printWarning("No ~/.claude/skills/ directory found; nothing to uninstall");
       return;
     }
     let removed = 0;
-    for (const name of fs94.readdirSync(skillsDir)) {
+    for (const name of fs95.readdirSync(skillsDir)) {
       const full = path93.join(skillsDir, name);
       try {
-        const stat = fs94.lstatSync(full);
+        const stat = fs95.lstatSync(full);
         if (!stat.isSymbolicLink()) continue;
-        const target = fs94.readlinkSync(full);
-        if (isChainSkill(name) || /\/10x[-:]/.test(target)) {
-          fs94.unlinkSync(full);
+        const target = fs95.readlinkSync(full);
+        if (isChainSkill(name) || /\/(100x|10x)[-:]/.test(target)) {
+          fs95.unlinkSync(full);
           removed += 1;
         }
       } catch {
       }
     }
-    printSuccess(`Removed ${removed} /10x: chain skill symlink(s)`);
+    printSuccess(`Removed ${removed} /100x: chain skill symlink(s)`);
     console.log("User-authored + non-chain skill sources preserved");
   });
   tenx.command("doctor").description(
-    "Diagnose /10x: chain skill installation + beads bootstrap state"
+    "Diagnose /100x: chain skill installation + beads bootstrap state"
   ).action(() => {
-    console.log("=== /10x: chain skills + beads health ===");
+    console.log("=== /100x: chain skills + beads health ===");
     const installed = listInstalledClaudeSkills();
     const chainInstalled = installed.filter(isChainSkill);
     console.log(
-      `  /10x: chain skills:     ${chainInstalled.length} / ${CHAIN_SKILL_NAMES.length} installed`
+      `  /100x: chain skills:    ${chainInstalled.length} / ${CHAIN_SKILL_NAMES.length} installed`
     );
     for (const canonical of CHAIN_SKILL_NAMES) {
-      const slug = canonical.replace(/^10x:/, "");
+      const slug = canonical.replace(/^100x:/, "");
       const found = installed.some(
-        (n) => n.toLowerCase() === canonical.toLowerCase() || n.toLowerCase() === slug || n.toLowerCase() === `10x-${slug}`
+        (n) => n.toLowerCase() === canonical.toLowerCase() || n.toLowerCase() === slug || n.toLowerCase() === `100x-${slug}` || n.toLowerCase() === `10x:${slug}` || n.toLowerCase() === `10x-${slug}`
       );
       console.log(`    ${found ? "\u2713" : "\u2717"} ${canonical}`);
     }
@@ -49006,11 +49343,11 @@ function registerSkills10x(program2) {
     const allChainPresent = chainInstalled.length === CHAIN_SKILL_NAMES.length;
     const allOk = allChainPresent && bdCli && bdInit && bdHooks;
     if (allOk) {
-      printSuccess("All /10x: chain skill + beads checks pass");
+      printSuccess("All /100x: chain skill + beads checks pass");
       return;
     }
     const fixHints = [];
-    if (!allChainPresent) fixHints.push("olam skills 10x install");
+    if (!allChainPresent) fixHints.push("olam 100x install");
     if (!bdCli) fixHints.push("brew install beads OR npm i -g @beads/bd");
     if (!bdInit) fixHints.push("bd init");
     if (!bdHooks) fixHints.push("bd setup claude");
@@ -49024,7 +49361,7 @@ function registerSkills10x(program2) {
     const olamVersion = readCliVersion();
     const sources = listSkillSources();
     console.log(`olam-cli:           ${olamVersion}`);
-    console.log(`chain canonical:    ${CHAIN_SKILL_NAMES.length} skills (/10x: chain)`);
+    console.log(`chain canonical:    ${CHAIN_SKILL_NAMES.length} skills (/100x: chain)`);
     console.log(`registered sources: ${sources.length}`);
     for (const s of sources) {
       const shortId = s.id ? s.id.slice(0, 8) : "????????";
@@ -49040,7 +49377,7 @@ function registerSkills10x(program2) {
 
 // src/commands/hermes.ts
 init_output();
-import * as fs95 from "node:fs";
+import * as fs96 from "node:fs";
 import * as os51 from "node:os";
 import * as path94 from "node:path";
 import * as child_process from "node:child_process";
@@ -49055,7 +49392,7 @@ function claudeSkillsDir() {
   return path94.join(os51.homedir(), ".claude", "skills");
 }
 function readHermesConfig(configPath) {
-  const raw = fs95.readFileSync(configPath, "utf-8");
+  const raw = fs96.readFileSync(configPath, "utf-8");
   const parsed = yamlParse2(raw);
   if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error(`${configPath} is not a YAML mapping`);
@@ -49063,13 +49400,13 @@ function readHermesConfig(configPath) {
   return parsed;
 }
 function writeHermesConfig(configPath, config) {
-  fs95.writeFileSync(configPath, yamlStringify3(config), "utf-8");
+  fs96.writeFileSync(configPath, yamlStringify3(config), "utf-8");
 }
 function resolveOlamBinary() {
   try {
     const result = child_process.spawnSync("which", ["olam"], { encoding: "utf-8" });
     const found = result.stdout.trim();
-    if (found && fs95.existsSync(found)) return found;
+    if (found && fs96.existsSync(found)) return found;
   } catch {
   }
   return process.argv[1] ?? "olam";
@@ -49082,7 +49419,7 @@ function resolveWorkspaceDir() {
       { encoding: "utf-8" }
     );
     const out = result.stdout.trim();
-    if (out && fs95.existsSync(out)) return out;
+    if (out && fs96.existsSync(out)) return out;
   } catch {
   }
   return process.cwd();
@@ -49152,22 +49489,22 @@ function ensureTerminalBackendLocal(config, dryRun, summary2) {
 }
 function mirrorSkillSymlinks(dryRun, summary2) {
   const srcDir = claudeSkillsDir();
-  if (!fs95.existsSync(srcDir)) {
+  if (!fs96.existsSync(srcDir)) {
     summary2.skipped.push("skills mirror (no ~/.claude/skills/ found)");
     return;
   }
   const destDir = hermesSkillsDir();
   if (!dryRun) {
-    fs95.mkdirSync(destDir, { recursive: true });
+    fs96.mkdirSync(destDir, { recursive: true });
   }
-  const entries = fs95.readdirSync(srcDir);
+  const entries = fs96.readdirSync(srcDir);
   let mirrored = 0;
   let collisions = 0;
   for (const entry of entries) {
     const srcPath = path94.join(srcDir, entry);
     const destPath2 = path94.join(destDir, entry);
-    if (fs95.existsSync(destPath2) || fs95.lstatSync(srcPath).isFile()) {
-      if (fs95.existsSync(destPath2)) collisions++;
+    if (fs96.existsSync(destPath2) || fs96.lstatSync(srcPath).isFile()) {
+      if (fs96.existsSync(destPath2)) collisions++;
       continue;
     }
     if (dryRun) {
@@ -49175,7 +49512,7 @@ function mirrorSkillSymlinks(dryRun, summary2) {
       continue;
     }
     try {
-      fs95.symlinkSync(srcPath, destPath2);
+      fs96.symlinkSync(srcPath, destPath2);
       mirrored++;
     } catch (err) {
       printWarning(`skills mirror: skipping ${entry} \u2014 ${err instanceof Error ? err.message : String(err)}`);
@@ -49194,7 +49531,7 @@ async function runHermesBootstrap(opts, deps = {}) {
   const writeConfig2 = deps.writeConfig ?? writeHermesConfig;
   const mirrorSkillsFn = deps.mirrorSkills ?? mirrorSkillSymlinks;
   const installHookFn = deps.installHook ?? installKgFirstHookForHermes;
-  if (!fs95.existsSync(configPath)) {
+  if (!fs96.existsSync(configPath)) {
     printError(`~/.hermes/config.yaml not found at ${configPath}`);
     printInfo(
       "remedy",
@@ -49311,7 +49648,7 @@ function registerStop(program2) {
 }
 
 // src/lib/upgrade-check.ts
-import * as fs96 from "node:fs";
+import * as fs97 from "node:fs";
 import * as os52 from "node:os";
 import * as path95 from "node:path";
 var UPGRADE_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
@@ -49330,7 +49667,7 @@ function isNewer(latest, current) {
 }
 function readCache(cachePath) {
   try {
-    const raw = fs96.readFileSync(cachePath, "utf-8");
+    const raw = fs97.readFileSync(cachePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed === "object" && parsed !== null && typeof parsed["checkedAt"] === "number" && typeof parsed["latestVersion"] === "string") {
       return parsed;
@@ -49342,8 +49679,8 @@ function readCache(cachePath) {
 function writeCache(cachePath, data) {
   try {
     const dir = path95.dirname(cachePath);
-    fs96.mkdirSync(dir, { recursive: true });
-    fs96.writeFileSync(cachePath, JSON.stringify(data), "utf-8");
+    fs97.mkdirSync(dir, { recursive: true });
+    fs97.writeFileSync(cachePath, JSON.stringify(data), "utf-8");
   } catch {
   }
 }
@@ -49486,17 +49823,17 @@ function registerWorldUpgrade(program2) {
 
 // src/commands/mcp/serve.ts
 init_output();
-import { existsSync as existsSync104 } from "node:fs";
-import { dirname as dirname59, resolve as resolve26 } from "node:path";
-import { fileURLToPath as fileURLToPath9 } from "node:url";
-var here2 = dirname59(fileURLToPath9(import.meta.url));
+import { existsSync as existsSync106 } from "node:fs";
+import { dirname as dirname60, resolve as resolve27 } from "node:path";
+import { fileURLToPath as fileURLToPath10 } from "node:url";
+var here2 = dirname60(fileURLToPath10(import.meta.url));
 var BUNDLE_PATH_CANDIDATES = [
   // bundled (`dist/index.js` after bundle-cli.mjs) — sibling
-  resolve26(here2, "mcp-server.js"),
+  resolve27(here2, "mcp-server.js"),
   // dev / tsc-only (`dist/commands/mcp/serve.js`) — up two levels
-  resolve26(here2, "..", "..", "mcp-server.js")
+  resolve27(here2, "..", "..", "mcp-server.js")
 ];
-function resolveBundlePath(candidates2 = BUNDLE_PATH_CANDIDATES, exists = existsSync104) {
+function resolveBundlePath(candidates2 = BUNDLE_PATH_CANDIDATES, exists = existsSync106) {
   return candidates2.find(exists) ?? null;
 }
 var MISSING_BUNDLE_REMEDY = "olam mcp server bundle missing. Searched: " + BUNDLE_PATH_CANDIDATES.join(", ") + ". For local dev, run: node packages/cli/scripts/bundle-mcp-server.mjs. A fresh `npm install -g @pleri/olam-cli@latest` should always include the bundle (see prepublishOnly in packages/cli/package.json); file an issue if it does not.";
@@ -49760,7 +50097,7 @@ function registerMcpComplete(cmd) {
 init_output();
 import * as readline6 from "node:readline";
 async function readTokenSilent(prompt) {
-  return new Promise((resolve30, reject) => {
+  return new Promise((resolve31, reject) => {
     const rl = readline6.createInterface({
       input: process.stdin,
       output: process.stdout,
@@ -49778,7 +50115,7 @@ async function readTokenSilent(prompt) {
         process.stdin.removeListener("data", onData);
         process.stdout.write("\n");
         rl.close();
-        resolve30(token);
+        resolve31(token);
       } else if (char === "") {
         if (process.stdin.isTTY) process.stdin.setRawMode(false);
         process.stdin.removeListener("data", onData);
@@ -49933,12 +50270,12 @@ import * as readline7 from "node:readline";
 import pc45 from "picocolors";
 
 // src/commands/mcp/import-discovery.ts
-import * as fs97 from "node:fs";
+import * as fs98 from "node:fs";
 import * as os53 from "node:os";
 import * as path96 from "node:path";
 function readJsonFile(filePath) {
   try {
-    const raw = fs97.readFileSync(filePath, "utf-8");
+    const raw = fs98.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -49982,9 +50319,9 @@ function getOlamRepoPaths() {
   ];
   const paths = [];
   for (const configPath of configPaths) {
-    if (!fs97.existsSync(configPath)) continue;
+    if (!fs98.existsSync(configPath)) continue;
     try {
-      const raw = fs97.readFileSync(configPath, "utf-8");
+      const raw = fs98.readFileSync(configPath, "utf-8");
       const repoMatches = [...raw.matchAll(/path:\s*["']?([^\s"'\n]+)/g)];
       for (const m of repoMatches) {
         if (m[1]) paths.push(m[1]);
@@ -50053,7 +50390,7 @@ async function discoverMcpSources(repoPaths) {
 import { spawn as spawn10 } from "node:child_process";
 var VALIDATION_TIMEOUT_MS = 5e3;
 async function validateMcpEntry(entry) {
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     let stdout = "";
     let timedOut = false;
     let child;
@@ -50063,7 +50400,7 @@ async function validateMcpEntry(entry) {
         env: { ...process.env, ...entry.env ?? {} }
       });
     } catch (err) {
-      resolve30({
+      resolve31({
         name: entry.name,
         validated: false,
         reason: err instanceof Error ? err.message : "spawn failed"
@@ -50080,11 +50417,11 @@ async function validateMcpEntry(entry) {
     child.on("close", (code) => {
       clearTimeout(timer);
       if (timedOut) {
-        resolve30({ name: entry.name, validated: false, reason: "timeout (5s)" });
+        resolve31({ name: entry.name, validated: false, reason: "timeout (5s)" });
         return;
       }
       const validated = code === 0 && stdout.trim().length > 0;
-      resolve30({
+      resolve31({
         name: entry.name,
         validated,
         reason: validated ? "ok" : `exit code ${code ?? "null"}`
@@ -50092,7 +50429,7 @@ async function validateMcpEntry(entry) {
     });
     child.on("error", (err) => {
       clearTimeout(timer);
-      resolve30({ name: entry.name, validated: false, reason: err.message });
+      resolve31({ name: entry.name, validated: false, reason: err.message });
     });
   });
 }
@@ -50107,11 +50444,11 @@ async function multiSelectPicker(entries) {
     );
   });
   console.log("\n" + pc45.dim('Enter numbers to import (e.g. 1,2,3 or "all" or Enter to skip):'));
-  const answer = await new Promise((resolve30) => {
+  const answer = await new Promise((resolve31) => {
     const rl = readline7.createInterface({ input: process.stdin, output: process.stdout });
     rl.question("> ", (ans) => {
       rl.close();
-      resolve30(ans.trim());
+      resolve31(ans.trim());
     });
   });
   if (!answer || answer === "") return [];
@@ -50258,14 +50595,14 @@ init_output();
 
 // src/lib/memory-host-process-migration.ts
 init_paths2();
-import { existsSync as existsSync106, readFileSync as readFileSync92, unlinkSync as unlinkSync23 } from "node:fs";
+import { existsSync as existsSync108, readFileSync as readFileSync94, unlinkSync as unlinkSync23 } from "node:fs";
 import { spawnSync as spawnSync31 } from "node:child_process";
 var KILL_TIMEOUT_MS = 5e3;
 function migrateFromHostProcess(opts = {}) {
   const pidPath2 = opts.pidPath ?? MEMORY_PID_PATH;
   const logPath = opts.logPath ?? MEMORY_LOG_PATH;
-  const pidfileExists = existsSync106(pidPath2);
-  const logExists = existsSync106(logPath);
+  const pidfileExists = existsSync108(pidPath2);
+  const logExists = existsSync108(logPath);
   if (!pidfileExists && !logExists) {
     return { cleaned: false, summary: "no legacy host-process state to clean" };
   }
@@ -50304,7 +50641,7 @@ function migrateFromHostProcess(opts = {}) {
 }
 function readPidFromFile(pidPath2) {
   try {
-    const raw = readFileSync92(pidPath2, "utf8").trim();
+    const raw = readFileSync94(pidPath2, "utf8").trim();
     const pid = parseInt(raw, 10);
     if (!Number.isFinite(pid) || pid <= 0) return null;
     return pid;
@@ -50434,7 +50771,7 @@ function registerMemoryStop(cmd) {
 init_output();
 init_memory_secret();
 init_paths2();
-import { existsSync as existsSync107 } from "node:fs";
+import { existsSync as existsSync109 } from "node:fs";
 var RESTART_CHURN_THRESHOLD = 3;
 async function probe(secret) {
   try {
@@ -50461,7 +50798,7 @@ async function collectMemoryStatus() {
     livez,
     secretSet: hasMemorySecret(),
     port: MEMORY_REST_PORT,
-    legacyPidfilePresent: existsSync107(MEMORY_PID_PATH),
+    legacyPidfilePresent: existsSync109(MEMORY_PID_PATH),
     startedAt: runtime?.startedAt ?? null,
     restartCount: runtime?.restartCount ?? null,
     health: runtime?.health ?? "unknown"
@@ -50548,8 +50885,8 @@ async function runMemoryLogs(opts) {
   args.push(MEMORY_SERVICE_CONTAINER);
   printHeader(`olam memory logs (${opts.follow ? "follow" : `tail -n ${tailN}`})`);
   const child = spawn11("docker", args, { stdio: "inherit" });
-  return new Promise((resolve30) => {
-    child.on("exit", (code) => resolve30(code ?? 0));
+  return new Promise((resolve31) => {
+    child.on("exit", (code) => resolve31(code ?? 0));
   });
 }
 function registerMemoryLogs(cmd) {
@@ -50685,14 +51022,14 @@ function registerMemoryUninstall(cmd) {
 init_schema2();
 init_output();
 init_memory_secret();
-import { existsSync as existsSync108, readFileSync as readFileSync93, writeFileSync as writeFileSync56 } from "node:fs";
-import { join as join105 } from "node:path";
+import { existsSync as existsSync110, readFileSync as readFileSync95, writeFileSync as writeFileSync58 } from "node:fs";
+import { join as join106 } from "node:path";
 import * as readline8 from "node:readline/promises";
 import { parse as parseYaml9, stringify as stringifyYaml7 } from "yaml";
 var CONFIG_REL = ".olam/config.yaml";
 function locateConfig(cwd) {
-  const absPath = join105(cwd, CONFIG_REL);
-  if (!existsSync108(absPath)) {
+  const absPath = join106(cwd, CONFIG_REL);
+  if (!existsSync110(absPath)) {
     throw new Error(
       `No ${CONFIG_REL} at ${cwd}. Run \`olam init\` in your workspace root first.`
     );
@@ -50700,7 +51037,7 @@ function locateConfig(cwd) {
   return { absPath };
 }
 function readConfigYaml(absPath) {
-  const raw = readFileSync93(absPath, "utf-8");
+  const raw = readFileSync95(absPath, "utf-8");
   const parsed = parseYaml9(raw) ?? {};
   if (typeof parsed !== "object" || parsed === null) {
     throw new Error(`${absPath} is not a YAML object`);
@@ -50709,7 +51046,7 @@ function readConfigYaml(absPath) {
 }
 function writeConfigYaml(absPath, parsed) {
   const out = stringifyYaml7(parsed, { aliasDuplicateObjects: false });
-  writeFileSync56(absPath, out, "utf-8");
+  writeFileSync58(absPath, out, "utf-8");
 }
 async function defaultPromptText(question) {
   const rl = readline8.createInterface({ input: process.stdin, output: process.stdout });
@@ -50830,20 +51167,20 @@ init_output();
 init_memory_secret();
 init_paths2();
 import { spawn as spawn12 } from "node:child_process";
-import { existsSync as existsSync109 } from "node:fs";
-import { join as join106 } from "node:path";
+import { existsSync as existsSync111 } from "node:fs";
+import { join as join107 } from "node:path";
 var DEFAULT_PORT2 = 8788;
 function resolveMemoryServiceDir() {
   for (const c of MEMORY_SERVICE_CANDIDATES) {
-    if (existsSync109(c)) return c;
+    if (existsSync111(c)) return c;
   }
   throw new Error(
     `Could not find packages/memory-service/. Searched: ${MEMORY_SERVICE_CANDIDATES.join(", ")}. If running from a published @pleri/olam-cli tarball, this is a packaging bug \u2014 please file an issue.`
   );
 }
 function resolveLocalBridgeScript(serviceDir) {
-  const path106 = join106(serviceDir, "scripts", "local-bridge-server.mjs");
-  if (!existsSync109(path106)) {
+  const path106 = join107(serviceDir, "scripts", "local-bridge-server.mjs");
+  if (!existsSync111(path106)) {
     throw new Error(
       `Could not find local-bridge-server.mjs at ${path106}. Verify packages/memory-service ships the scripts/ directory.`
     );
@@ -50891,12 +51228,12 @@ async function runBridgeServe(opts, deps = {}) {
     stdio: "inherit"
   }));
   const child = spawner(process.execPath, [scriptPath, ...args], env);
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     let resolved = false;
     const finish = (code) => {
       if (resolved) return;
       resolved = true;
-      resolve30(code);
+      resolve31(code);
     };
     const forward = (signal) => () => {
       if (!child.killed) {
@@ -51184,38 +51521,38 @@ function registerMemoryStats(cmd) {
 }
 
 // src/commands/memory/install-hooks.ts
-import { copyFileSync as copyFileSync12, existsSync as existsSync110, mkdirSync as mkdirSync64, readFileSync as readFileSync94, writeFileSync as writeFileSync57 } from "node:fs";
-import { homedir as homedir62 } from "node:os";
-import { dirname as dirname60, join as join107, resolve as resolve27 } from "node:path";
-import { fileURLToPath as fileURLToPath10 } from "node:url";
+import { copyFileSync as copyFileSync12, existsSync as existsSync112, mkdirSync as mkdirSync65, readFileSync as readFileSync96, writeFileSync as writeFileSync59 } from "node:fs";
+import { homedir as homedir63 } from "node:os";
+import { dirname as dirname61, join as join108, resolve as resolve28 } from "node:path";
+import { fileURLToPath as fileURLToPath11 } from "node:url";
 var HOOK_BASENAMES = [
   "agentmemory-session-recall.js",
   "agentmemory-recall-trigger.mjs",
   "agentmemory-classify-queue.mjs"
 ];
 function defaultSourceDir() {
-  const here3 = dirname60(fileURLToPath10(import.meta.url));
-  const candidate = resolve27(here3, "..", "..", "..", "memory-service", "hooks");
-  if (existsSync110(candidate)) return candidate;
-  const srcCandidate = resolve27(here3, "..", "..", "..", "..", "memory-service", "hooks");
-  if (existsSync110(srcCandidate)) return srcCandidate;
+  const here3 = dirname61(fileURLToPath11(import.meta.url));
+  const candidate = resolve28(here3, "..", "..", "..", "memory-service", "hooks");
+  if (existsSync112(candidate)) return candidate;
+  const srcCandidate = resolve28(here3, "..", "..", "..", "..", "memory-service", "hooks");
+  if (existsSync112(srcCandidate)) return srcCandidate;
   return candidate;
 }
 function installOne2(basename17, sourceDir, targetDir, opts) {
-  const sourcePath = join107(sourceDir, basename17);
-  const targetPath = join107(targetDir, basename17);
-  if (!existsSync110(sourcePath)) {
+  const sourcePath = join108(sourceDir, basename17);
+  const targetPath = join108(targetDir, basename17);
+  if (!existsSync112(sourcePath)) {
     throw new Error(`canonical hook source missing at ${sourcePath} \u2014 olam install corrupt or sourceDir is wrong`);
   }
-  const newContent = readFileSync94(sourcePath, "utf8");
-  if (!existsSync110(targetPath)) {
+  const newContent = readFileSync96(sourcePath, "utf8");
+  if (!existsSync112(targetPath)) {
     if (opts.dryRun !== true) {
-      mkdirSync64(dirname60(targetPath), { recursive: true });
-      writeFileSync57(targetPath, newContent, { mode: 493 });
+      mkdirSync65(dirname61(targetPath), { recursive: true });
+      writeFileSync59(targetPath, newContent, { mode: 493 });
     }
     return { basename: basename17, action: "written", targetPath };
   }
-  const existing = readFileSync94(targetPath, "utf8");
+  const existing = readFileSync96(targetPath, "utf8");
   if (existing === newContent) {
     return { basename: basename17, action: "unchanged", targetPath };
   }
@@ -51223,7 +51560,7 @@ function installOne2(basename17, sourceDir, targetDir, opts) {
     const backupPath = `${targetPath}.agentmemory-hook-backup-${Math.floor(Date.now() / 1e3)}`;
     if (opts.dryRun !== true) {
       copyFileSync12(targetPath, backupPath);
-      writeFileSync57(targetPath, newContent, { mode: 493 });
+      writeFileSync59(targetPath, newContent, { mode: 493 });
     }
     return { basename: basename17, action: "force-overwritten", targetPath, backupPath };
   }
@@ -51238,13 +51575,13 @@ Add these hook entries to ~/.claude/settings.json:
 {
   "hooks": {
     "SessionStart": [
-      { "command": "node ${join107(targetDir, "agentmemory-session-recall.js")}" }
+      { "command": "node ${join108(targetDir, "agentmemory-session-recall.js")}" }
     ],
     "PreToolUse": [
-      { "command": "node ${join107(targetDir, "agentmemory-recall-trigger.mjs")}" }
+      { "command": "node ${join108(targetDir, "agentmemory-recall-trigger.mjs")}" }
     ],
     "PostToolUse": [
-      { "command": "node ${join107(targetDir, "agentmemory-classify-queue.mjs")}" }
+      { "command": "node ${join108(targetDir, "agentmemory-classify-queue.mjs")}" }
     ]
   }
 }
@@ -51254,7 +51591,7 @@ If existing entries already point at the same paths, no edit needed.
 }
 function registerMemoryInstallHooks(parent) {
   parent.command("install-hooks").description("Install agentmemory hooks (PreToolUse + PostToolUse + SessionStart) to ~/.claude/scripts/hooks/").option("--force", "overwrite existing non-canonical files (backs them up to .agentmemory-hook-backup-<ts>)").option("--dry-run", "preview which hooks would be written without modifying disk").option("--target-dir <path>", "override target directory (default: ~/.claude/scripts/hooks/); for tests").option("--source-dir <path>", "override source directory (default: packages/memory-service/hooks/); for tests").action((opts) => {
-    const targetDir = opts.targetDir ?? join107(homedir62(), ".claude", "scripts", "hooks");
+    const targetDir = opts.targetDir ?? join108(homedir63(), ".claude", "scripts", "hooks");
     const sourceDir = opts.sourceDir ?? defaultSourceDir();
     let written = 0;
     let unchanged = 0;
@@ -51330,7 +51667,7 @@ function registerMemory(program2) {
 // src/commands/kg-build.ts
 init_storage_paths();
 init_workspace_name();
-import * as fs103 from "node:fs";
+import * as fs104 from "node:fs";
 import * as os57 from "node:os";
 import * as path102 from "node:path";
 
@@ -51424,11 +51761,11 @@ init_storage_paths();
 init_workspace_name();
 init_kg_caps();
 init_output();
-import fs98 from "node:fs";
-import { homedir as homedir63 } from "node:os";
+import fs99 from "node:fs";
+import { homedir as homedir64 } from "node:os";
 import path97 from "node:path";
 function olamHome5() {
-  return process.env.OLAM_HOME ?? path97.join(homedir63(), ".olam");
+  return process.env.OLAM_HOME ?? path97.join(homedir64(), ".olam");
 }
 function kgRoot2() {
   return path97.join(olamHome5(), "kg");
@@ -51437,14 +51774,14 @@ function worldsRoot2() {
   return path97.join(olamHome5(), "worlds");
 }
 function dirSizeBytes2(dir) {
-  if (!fs98.existsSync(dir)) return 0;
+  if (!fs99.existsSync(dir)) return 0;
   let total = 0;
   const stack = [dir];
   while (stack.length > 0) {
     const cur = stack.pop();
     let entries;
     try {
-      entries = fs98.readdirSync(cur, { withFileTypes: true });
+      entries = fs99.readdirSync(cur, { withFileTypes: true });
     } catch {
       continue;
     }
@@ -51456,7 +51793,7 @@ function dirSizeBytes2(dir) {
         continue;
       }
       try {
-        total += fs98.statSync(full).size;
+        total += fs99.statSync(full).size;
       } catch {
       }
     }
@@ -51471,9 +51808,9 @@ function formatBytes5(n) {
 }
 function readFreshness(workspace) {
   const file = path97.join(kgPristinePath(workspace), "freshness.json");
-  if (!fs98.existsSync(file)) return null;
+  if (!fs99.existsSync(file)) return null;
   try {
-    const raw = JSON.parse(fs98.readFileSync(file, "utf-8"));
+    const raw = JSON.parse(fs99.readFileSync(file, "utf-8"));
     if (raw && typeof raw === "object") return raw;
     return null;
   } catch {
@@ -51482,9 +51819,9 @@ function readFreshness(workspace) {
 }
 function readOverlayNodeCount(graphifyOutDir) {
   const graphPath = path97.join(graphifyOutDir, "graph.json");
-  if (!fs98.existsSync(graphPath)) return null;
+  if (!fs99.existsSync(graphPath)) return null;
   try {
-    const raw = JSON.parse(fs98.readFileSync(graphPath, "utf-8"));
+    const raw = JSON.parse(fs99.readFileSync(graphPath, "utf-8"));
     if (raw && typeof raw === "object") {
       const nodes = raw.nodes;
       if (Array.isArray(nodes)) return nodes.length;
@@ -51496,11 +51833,11 @@ function readOverlayNodeCount(graphifyOutDir) {
 }
 function listOverlays() {
   const root = worldsRoot2();
-  if (!fs98.existsSync(root)) return [];
+  if (!fs99.existsSync(root)) return [];
   const records = [];
   let worldDirs;
   try {
-    worldDirs = fs98.readdirSync(root, { withFileTypes: true });
+    worldDirs = fs99.readdirSync(root, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -51510,14 +51847,14 @@ function listOverlays() {
     const worldDir = path97.join(root, worldId);
     let cloneDirs;
     try {
-      cloneDirs = fs98.readdirSync(worldDir, { withFileTypes: true });
+      cloneDirs = fs99.readdirSync(worldDir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const cloneEntry of cloneDirs) {
       if (!cloneEntry.isDirectory()) continue;
       const graphifyOut = path97.join(worldDir, cloneEntry.name, "graphify-out");
-      if (!fs98.existsSync(graphifyOut)) continue;
+      if (!fs99.existsSync(graphifyOut)) continue;
       records.push({
         world_id: worldId,
         clone_dir: cloneEntry.name,
@@ -51531,11 +51868,11 @@ function listOverlays() {
 }
 function listPristines(overlays) {
   const root = kgRoot2();
-  if (!fs98.existsSync(root)) return [];
+  if (!fs99.existsSync(root)) return [];
   const records = [];
   let entries;
   try {
-    entries = fs98.readdirSync(root, { withFileTypes: true });
+    entries = fs99.readdirSync(root, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -51684,7 +52021,7 @@ init_storage_paths();
 init_workspace_name();
 init_output();
 import { spawn as spawn13 } from "node:child_process";
-import fs99 from "node:fs";
+import fs100 from "node:fs";
 import path98 from "node:path";
 function pidFilePath2(workspace) {
   return path98.join(kgPristinePath(workspace), ".watch.pid");
@@ -51702,33 +52039,33 @@ function isPidAlive3(pid) {
 }
 function readAndClassifyPid(workspace) {
   const file = pidFilePath2(workspace);
-  if (!fs99.existsSync(file)) return { status: "no-pidfile", pid: null };
+  if (!fs100.existsSync(file)) return { status: "no-pidfile", pid: null };
   let pid;
   try {
-    const raw = fs99.readFileSync(file, "utf-8").trim();
+    const raw = fs100.readFileSync(file, "utf-8").trim();
     pid = Number.parseInt(raw, 10);
   } catch {
-    fs99.rmSync(file, { force: true });
+    fs100.rmSync(file, { force: true });
     return { status: "stale-reclaimed", pid: null };
   }
   if (!Number.isInteger(pid) || pid <= 0) {
-    fs99.rmSync(file, { force: true });
+    fs100.rmSync(file, { force: true });
     return { status: "stale-reclaimed", pid: null };
   }
   if (isPidAlive3(pid)) return { status: "active", pid };
-  fs99.rmSync(file, { force: true });
+  fs100.rmSync(file, { force: true });
   return { status: "stale-reclaimed", pid: null };
 }
 function writePidFile2(workspace, pid) {
   const file = pidFilePath2(workspace);
   const dir = path98.dirname(file);
-  fs99.mkdirSync(dir, { recursive: true });
-  fs99.writeFileSync(file, String(pid), { encoding: "utf-8" });
+  fs100.mkdirSync(dir, { recursive: true });
+  fs100.writeFileSync(file, String(pid), { encoding: "utf-8" });
 }
 function removePidFile(workspace) {
   const file = pidFilePath2(workspace);
   try {
-    fs99.rmSync(file, { force: true });
+    fs100.rmSync(file, { force: true });
   } catch {
   }
 }
@@ -51782,16 +52119,16 @@ async function runKgWatch(workspaceArg, opts, deps = {}) {
     process.on("SIGINT", () => forward("SIGINT"));
     process.on("SIGTERM", () => forward("SIGTERM"));
   }
-  return new Promise((resolve30) => {
+  return new Promise((resolve31) => {
     child.on("exit", (code, signal) => {
       removePidFile(name);
       const exitCode = typeof code === "number" ? code : signal === "SIGINT" || signal === "SIGTERM" ? 0 : 1;
-      resolve30({ exitCode, pidWritten: true });
+      resolve31({ exitCode, pidWritten: true });
     });
     child.on("error", (err) => {
       removePidFile(name);
       printError(`graphify subprocess error: ${err.message}`);
-      resolve30({ exitCode: 1, pidWritten: true });
+      resolve31({ exitCode: 1, pidWritten: true });
     });
   });
 }
@@ -52055,7 +52392,7 @@ function registerKgDoctorCommand(kg) {
 init_merge_settings();
 init_hook_template2();
 init_output();
-import * as fs100 from "node:fs";
+import * as fs101 from "node:fs";
 import * as path99 from "node:path";
 import * as os54 from "node:os";
 import { parse as yamlParse3, stringify as yamlStringify4 } from "yaml";
@@ -52066,10 +52403,10 @@ function settingsPathFor2(scope) {
   return path99.join(process.cwd(), ".claude", "settings.json");
 }
 function backup2(filePath) {
-  if (!fs100.existsSync(filePath)) return null;
+  if (!fs101.existsSync(filePath)) return null;
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const backupPath = `${filePath}.olam-bak.${ts}`;
-  fs100.copyFileSync(filePath, backupPath);
+  fs101.copyFileSync(filePath, backupPath);
   return backupPath;
 }
 var HERMES_HOOK_MATCHERS = ["terminal", "bash", "shell", "search_files", "grep", "ripgrep"];
@@ -52081,7 +52418,7 @@ function hermesHooksDir() {
 }
 function patchHermesConfigForHook(action) {
   const configPath = hermesConfigPath2();
-  const raw = fs100.readFileSync(configPath, "utf-8");
+  const raw = fs101.readFileSync(configPath, "utf-8");
   const config = yamlParse3(raw);
   const hooks = config["hooks"] ?? {};
   const preToolCall = Array.isArray(hooks["pre_tool_call"]) ? hooks["pre_tool_call"] : [];
@@ -52100,7 +52437,7 @@ function patchHermesConfigForHook(action) {
       hooks: { ...hooks, pre_tool_call: [...preToolCall, entry] },
       hooks_auto_accept: true
     };
-    fs100.writeFileSync(configPath, yamlStringify4(updated2), "utf-8");
+    fs101.writeFileSync(configPath, yamlStringify4(updated2), "utf-8");
     return "patched";
   }
   const filtered = preToolCall.filter(
@@ -52111,12 +52448,12 @@ function patchHermesConfigForHook(action) {
     ...config,
     hooks: { ...hooks, pre_tool_call: filtered }
   };
-  fs100.writeFileSync(configPath, yamlStringify4(updated), "utf-8");
+  fs101.writeFileSync(configPath, yamlStringify4(updated), "utf-8");
   return "patched";
 }
 function doInstallForHermes() {
   const configPath = hermesConfigPath2();
-  if (!fs100.existsSync(configPath)) {
+  if (!fs101.existsSync(configPath)) {
     printError(`~/.hermes/config.yaml not found at ${configPath}`);
     printInfo("remedy", "Install Hermes first, then re-run `olam kg install-hook --for hermes`");
     process.exitCode = 1;
@@ -52146,15 +52483,15 @@ function doUninstallForHermes() {
   const hooksDir = hermesHooksDir();
   const hookScriptPath = path99.join(hooksDir, "kg-first.sh");
   let scriptRemoved = false;
-  if (fs100.existsSync(hookScriptPath)) {
-    const content = fs100.readFileSync(hookScriptPath, "utf-8");
+  if (fs101.existsSync(hookScriptPath)) {
+    const content = fs101.readFileSync(hookScriptPath, "utf-8");
     if (content.includes(HERMES_KG_HOOK_SENTINEL)) {
-      fs100.unlinkSync(hookScriptPath);
+      fs101.unlinkSync(hookScriptPath);
       scriptRemoved = true;
     }
   }
   let configPatched = false;
-  if (fs100.existsSync(configPath)) {
+  if (fs101.existsSync(configPath)) {
     const result = patchHermesConfigForHook("uninstall");
     configPatched = result === "patched";
   }
@@ -52179,7 +52516,7 @@ function registerKgInstallHookCommand(kg) {
     const scope = opts.scope === "user" ? "user" : "project";
     const filePath = settingsPathFor2(scope);
     try {
-      fs100.mkdirSync(path99.dirname(filePath), { recursive: true });
+      fs101.mkdirSync(path99.dirname(filePath), { recursive: true });
     } catch (err) {
       printError(`could not create ${path99.dirname(filePath)}: ${err instanceof Error ? err.message : String(err)}`);
       process.exitCode = 1;
@@ -52205,7 +52542,7 @@ function registerKgInstallHookCommand(kg) {
           printInfo("kg-service hook", `already installed at ${filePath}`);
           if (backupPath) {
             try {
-              fs100.unlinkSync(backupPath);
+              fs101.unlinkSync(backupPath);
             } catch {
             }
           }
@@ -52225,7 +52562,7 @@ function registerKgInstallHookCommand(kg) {
 // src/commands/kg-uninstall-hook.ts
 init_hook_template2();
 init_output();
-import * as fs101 from "node:fs";
+import * as fs102 from "node:fs";
 import * as path100 from "node:path";
 import * as os55 from "node:os";
 function settingsPathFor3(scope) {
@@ -52262,13 +52599,13 @@ function registerKgUninstallHookCommand(kg) {
   kg.command("uninstall-hook").description("Remove kg-service PreToolUse hook from .claude/settings.json (sentinel-matched; surgical)").option("--scope <scope>", "project (default) or user", "project").action((opts) => {
     const scope = opts.scope === "user" ? "user" : "project";
     const filePath = settingsPathFor3(scope);
-    if (!fs101.existsSync(filePath)) {
+    if (!fs102.existsSync(filePath)) {
       printInfo("kg-service hook", `no settings.json at ${filePath} \u2014 nothing to remove`);
       return;
     }
     let settings;
     try {
-      const raw = fs101.readFileSync(filePath, "utf-8");
+      const raw = fs102.readFileSync(filePath, "utf-8");
       settings = raw.trim() ? JSON.parse(raw) : {};
     } catch (err) {
       printError(`could not parse ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
@@ -52288,7 +52625,7 @@ function registerKgUninstallHookCommand(kg) {
     const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
     const backupPath = `${filePath}.olam-bak.${ts}`;
     try {
-      fs101.copyFileSync(filePath, backupPath);
+      fs102.copyFileSync(filePath, backupPath);
     } catch {
     }
     const next = {
@@ -52307,7 +52644,7 @@ function registerKgUninstallHookCommand(kg) {
       }
     }
     try {
-      fs101.writeFileSync(filePath, JSON.stringify(next, null, 2) + "\n");
+      fs102.writeFileSync(filePath, JSON.stringify(next, null, 2) + "\n");
       printSuccess(`kg-service hook removed from ${filePath}`);
       printInfo("backup", backupPath);
     } catch (err) {
@@ -52380,7 +52717,7 @@ function registerKgSavingsCommand(kg) {
 
 // src/commands/kg-mirror.ts
 init_output();
-import * as fs102 from "node:fs";
+import * as fs103 from "node:fs";
 import * as os56 from "node:os";
 import * as path101 from "node:path";
 function readEnvOrFile(envVar, fileName) {
@@ -52388,7 +52725,7 @@ function readEnvOrFile(envVar, fileName) {
   if (fromEnv && fromEnv.length > 0) return fromEnv.trim();
   try {
     const file = path101.join(os56.homedir(), ".olam", fileName);
-    const content = fs102.readFileSync(file, "utf-8").trim();
+    const content = fs103.readFileSync(file, "utf-8").trim();
     if (content.length > 0) return content;
   } catch {
   }
@@ -52568,6 +52905,76 @@ async function runKgMirrorClassify(question, options = {}) {
   printInfo("est. savings", `~${Math.round(Number(savings2) / 1e3)}k tokens`);
   return { exitCode: 0 };
 }
+async function runKgMirrorGraph(symbol, options = {}) {
+  const cfg = resolveClassifier();
+  if (!cfg) {
+    printError(
+      "kg-mirror URL/bearer not configured. Set OLAM_KG_PROXY_URL + OLAM_KG_PROXY_BEARER (or ~/.olam/kg-proxy-url + ~/.olam/kg-proxy-bearer)."
+    );
+    return { exitCode: 3 };
+  }
+  if (!options.workspace) {
+    printError("graph query needs a --workspace (e.g. --workspace atlas-one).");
+    return { exitCode: 2 };
+  }
+  const sym = (symbol ?? "").trim();
+  if (!sym && !options.repo) {
+    printError("provide a <symbol> to search, and/or --repo <name> to browse a repo.");
+    return { exitCode: 2 };
+  }
+  const mode = options.relates ? "relates" : "where";
+  const body = { workspace: options.workspace, symbol: sym, mode };
+  if (options.repo) body.repo = options.repo;
+  if (options.limit) {
+    const n = Number.parseInt(options.limit, 10);
+    if (Number.isFinite(n) && n > 0) body.limit = n;
+  }
+  let res;
+  try {
+    res = await fetch(`${cfg.url}/v1/graph`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${cfg.bearer}`, "Content-Type": "application/json" },
+      body: JSON.stringify(body)
+    });
+  } catch (err) {
+    printError(`kg-mirror unreachable: ${err instanceof Error ? err.message : String(err)}`);
+    return { exitCode: 4 };
+  }
+  const text = await res.text();
+  if (options.json) {
+    process.stdout.write(text + "\n");
+    return { exitCode: res.ok ? 0 : 1 };
+  }
+  let j;
+  try {
+    j = JSON.parse(text);
+  } catch {
+    printError(`kg-mirror returned non-JSON (HTTP ${res.status}): ${text.slice(0, 200)}`);
+    return { exitCode: 1 };
+  }
+  if (!res.ok) {
+    printError(`graph /v1/graph failed (HTTP ${res.status}): ${j.error ?? "?"}`);
+    if (j.detail) printInfo("detail", String(j.detail));
+    return { exitCode: 1 };
+  }
+  const matched = j.matched ?? [];
+  printInfo("graph", `${options.workspace} \xB7 ${mode} \xB7 "${symbol}"`);
+  if (matched.length === 0) {
+    printInfo("matched", "no nodes match that symbol");
+  }
+  for (const m of matched) {
+    printSuccess(`${m.label}  ${m.file}:${String(m.loc ?? "").replace(/^L/, "")}`);
+  }
+  if (mode === "relates") {
+    const relates = j.relates ?? [];
+    for (const e of relates) {
+      const arrow = e.direction === "out" ? "\u2192" : "\u2190";
+      printInfo(String(e.relation), `${arrow} ${e.label}  (${e.file})`);
+    }
+  }
+  if (j.truncated) printInfo("note", "results truncated \u2014 pass --limit to widen");
+  return { exitCode: 0 };
+}
 function guessGitUrl(workspace) {
   try {
     const { spawnSync: spawnSync35 } = __require("node:child_process");
@@ -52578,7 +52985,7 @@ function guessGitUrl(workspace) {
       path101.join(os56.homedir(), "Projects", workspace)
     ];
     for (const dir of candidates2) {
-      if (!fs102.existsSync(path101.join(dir, ".git"))) continue;
+      if (!fs103.existsSync(path101.join(dir, ".git"))) continue;
       const r = spawnSync35("git", ["-C", dir, "remote", "get-url", "origin"], {
         encoding: "utf-8"
       });
@@ -52607,12 +53014,16 @@ function registerKgMirrorCommand(kg) {
     const r = await runKgMirrorClassify(question, opts);
     if (r.exitCode !== 0) process.exitCode = r.exitCode;
   });
+  mirror.command("graph").description("Query the cross-repo graph: locate a symbol, its relationships, or browse a repo (POST /v1/graph)").argument("[symbol]", "symbol/label to look up (e.g. UserService); omit with --repo to browse a repo").requiredOption("--workspace <name>", "workspace to query (e.g. atlas-one)").option("--repo <name>", "scope to / browse a submodule by path prefix (e.g. diner-app)").option("--relates", "return relationships (calls/imports/contains) instead of just locations").option("--limit <n>", "max results (default 50)").option("--json", "emit raw JSON response").action(async (symbol, opts) => {
+    const r = await runKgMirrorGraph(symbol, opts);
+    if (r.exitCode !== 0) process.exitCode = r.exitCode;
+  });
 }
 
 // src/commands/kg-build.ts
 function readQueueFromDisk(queuePath) {
-  if (!fs103.existsSync(queuePath)) return [];
-  const raw = fs103.readFileSync(queuePath, "utf-8");
+  if (!fs104.existsSync(queuePath)) return [];
+  const raw = fs104.readFileSync(queuePath, "utf-8");
   const entries = [];
   for (const line of raw.split("\n")) {
     const t = line.trim();
@@ -52625,9 +53036,9 @@ function readQueueFromDisk(queuePath) {
   return entries;
 }
 function writeQueueToDisk(queuePath, entries) {
-  fs103.mkdirSync(path102.dirname(queuePath), { recursive: true });
+  fs104.mkdirSync(path102.dirname(queuePath), { recursive: true });
   const content = entries.map((e) => JSON.stringify(e)).join("\n") + (entries.length > 0 ? "\n" : "");
-  fs103.writeFileSync(queuePath, content, "utf-8");
+  fs104.writeFileSync(queuePath, content, "utf-8");
 }
 async function runKgBuildPending(opts = {}) {
   const queuePath = opts.queuePath ?? (() => {
@@ -52717,7 +53128,7 @@ async function runKgBuild(workspaceArg, options = {}) {
     return { exitCode: 2 };
   }
   const outDir = kgPristinePath(workspace.name);
-  fs103.mkdirSync(outDir, { recursive: true });
+  fs104.mkdirSync(outDir, { recursive: true });
   const human = !options.json;
   if (human) {
     printInfo("kg build", `workspace=${workspace.name} source=${workspace.sourcePath}`);
@@ -52750,7 +53161,7 @@ async function runKgBuild(workspaceArg, options = {}) {
     workspace: workspace.name,
     graphify_path: "container"
   };
-  fs103.writeFileSync(
+  fs104.writeFileSync(
     path102.join(outDir, "freshness.json"),
     JSON.stringify(freshness, null, 2) + "\n",
     "utf-8"
@@ -52797,13 +53208,13 @@ function registerKg(program2) {
 
 // src/commands/flywheel/emit-breadcrumb.ts
 init_file_lock();
-import { mkdirSync as mkdirSync67, appendFileSync as appendFileSync6 } from "node:fs";
-import { homedir as homedir68 } from "node:os";
-import { dirname as dirname64, join as join112 } from "node:path";
+import { mkdirSync as mkdirSync68, appendFileSync as appendFileSync6 } from "node:fs";
+import { homedir as homedir69 } from "node:os";
+import { dirname as dirname65, join as join113 } from "node:path";
 import { randomUUID as randomUUID4 } from "node:crypto";
 var VALID_SEVERITIES = /* @__PURE__ */ new Set(["critical", "high", "medium", "low", "info", "warn"]);
 var PROMPT_FEEDING_FIELDS = ["extracted_pattern", "severity", "affected_persona", "proposed_edit"];
-var BREADCRUMBS_BASE = join112(homedir68(), ".local", "share", "claude", "breadcrumbs");
+var BREADCRUMBS_BASE = join113(homedir69(), ".local", "share", "claude", "breadcrumbs");
 var LOCK_FILENAME = ".flywheel-emit.lock";
 function buildRecord(opts) {
   const rec = {
@@ -52850,7 +53261,7 @@ function validatePromptFeeding(rec) {
 }
 function destPath(projectSlug) {
   const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  return join112(BREADCRUMBS_BASE, projectSlug, `${today}.jsonl`);
+  return join113(BREADCRUMBS_BASE, projectSlug, `${today}.jsonl`);
 }
 async function emitBreadcrumb(opts) {
   if (!VALID_SEVERITIES.has(opts.severity)) {
@@ -52870,8 +53281,8 @@ async function emitBreadcrumb(opts) {
     process.exit(2);
   }
   const path106 = destPath(rec.project_slug);
-  const lockDir = dirname64(path106);
-  mkdirSync67(lockDir, { recursive: true });
+  const lockDir = dirname65(path106);
+  mkdirSync68(lockDir, { recursive: true });
   const line = JSON.stringify(rec) + "\n";
   await withFileLock(
     lockDir,
@@ -52951,7 +53362,7 @@ function registerFlywheelK5Score(parent) {
 }
 
 // src/commands/flywheel/k5-validate.ts
-import { readFileSync as readFileSync99, statSync as statSync31 } from "node:fs";
+import { readFileSync as readFileSync101, statSync as statSync31 } from "node:fs";
 import { parse as parseYAML } from "yaml";
 var K5_DIMS = ["direction", "approach", "open_questions", "constraints", "reuse"];
 var MAX_PLAN_BYTES = 1048576;
@@ -53033,7 +53444,7 @@ function validatePlan(path106) {
   }
   let text;
   try {
-    text = readFileSync99(path106, "utf8");
+    text = readFileSync101(path106, "utf8");
   } catch (err) {
     const m = `FAIL cannot read ${path106}: ${err instanceof Error ? err.message : "unknown"}`;
     return { ok: false, message: m, json: emptyJson("error", [m]) };
@@ -53157,7 +53568,7 @@ function registerFlywheelK5Validate(parent) {
 }
 
 // src/commands/flywheel/k10-measure.ts
-import { readFileSync as readFileSync100 } from "node:fs";
+import { readFileSync as readFileSync102 } from "node:fs";
 
 // ../core/dist/lib/k10-budget.js
 var K10_TOKEN_CAP = 5500;
@@ -53214,7 +53625,7 @@ function registerFlywheelK10Measure(parent) {
   parent.command("k10-measure").description("Measure K10 token budget for upstream + optional overlay; emit PASS/REJECT verdict").requiredOption("--upstream <path>", "path to upstream file (e.g. persona prompt)").option("--overlay <path>", "path to overlay file (omit if none \u2014 PASS without enforcement)").option("--json", "emit verdict as JSON instead of human-readable").action((opts) => {
     let upstreamText;
     try {
-      upstreamText = readFileSync100(opts.upstream, "utf8");
+      upstreamText = readFileSync102(opts.upstream, "utf8");
     } catch (err) {
       process.stderr.write(
         `[k10-measure-error] cannot read upstream ${opts.upstream}: ${err instanceof Error ? err.message : "unknown"}
@@ -53226,7 +53637,7 @@ function registerFlywheelK10Measure(parent) {
     let overlayTokens = null;
     if (opts.overlay !== void 0) {
       try {
-        const overlayText = readFileSync100(opts.overlay, "utf8");
+        const overlayText = readFileSync102(opts.overlay, "utf8");
         overlayTokens = tokensFromText(overlayText);
       } catch (err) {
         process.stderr.write(
@@ -53260,13 +53671,13 @@ function registerFlywheelK10Measure(parent) {
 }
 
 // src/commands/flywheel/check-persona-skeleton.ts
-import { existsSync as existsSync115, readFileSync as readFileSync101, statSync as statSync32 } from "node:fs";
-import { homedir as homedir69 } from "node:os";
-import { basename as basename14, join as join113 } from "node:path";
+import { existsSync as existsSync117, readFileSync as readFileSync103, statSync as statSync32 } from "node:fs";
+import { homedir as homedir70 } from "node:os";
+import { basename as basename14, join as join114 } from "node:path";
 import { parse as parseYAML2 } from "yaml";
 var CHARS_PER_TOKEN3 = 4;
 var K10_TOKEN_CAP2 = 6e3;
-var AGENTS_DIR = join113(homedir69(), ".claude", "agents");
+var AGENTS_DIR = join114(homedir70(), ".claude", "agents");
 var REQUIRED_FRONTMATTER_KEYS = ["name", "description", "allowed-tools"];
 var REQUIRED_SECTIONS = [
   "## Role",
@@ -53306,10 +53717,10 @@ function countNamedPatterns(sectionText) {
   return Math.max(h3Count, bulletCount);
 }
 function checkFile(filepath) {
-  if (!existsSync115(filepath) || !statSync32(filepath).isFile()) {
+  if (!existsSync117(filepath) || !statSync32(filepath).isFile()) {
     return { passed: false, failures: [`file not found: ${filepath}`], tokens: 0, mergedSkipped: false };
   }
-  const text = readFileSync101(filepath, "utf8");
+  const text = readFileSync103(filepath, "utf8");
   const { fm, body } = parseFile(text);
   const failures = [];
   for (const key of REQUIRED_FRONTMATTER_KEYS) {
@@ -53322,8 +53733,8 @@ function checkFile(filepath) {
   const agentName = typeof fm.name === "string" ? fm.name : "";
   let mergedSkipped = false;
   if (!isNewAgent && agentName !== "") {
-    const upstreamPath = join113(AGENTS_DIR, `${agentName}.md`);
-    if (existsSync115(upstreamPath)) {
+    const upstreamPath = join114(AGENTS_DIR, `${agentName}.md`);
+    if (existsSync117(upstreamPath)) {
       mergedSkipped = true;
     }
   }
@@ -53375,7 +53786,7 @@ Results: ${passCount} passed, ${failCount} failed
 }
 
 // src/commands/flywheel/diversity-check.ts
-import { readFileSync as readFileSync102 } from "node:fs";
+import { readFileSync as readFileSync104 } from "node:fs";
 import { basename as basename15 } from "node:path";
 import { globSync as globSync2 } from "node:fs";
 
@@ -53455,7 +53866,7 @@ function formatRedivergencePrompt(personaA, personaB, score, drifted, revisionCo
     `  jaccard: ${score.toFixed(3)}  (threshold: ${threshold})`,
     `  drifted: ${driftedName}`,
     "",
-    `  Suggestion for next /10x:learn revision of ${driftedName}:`,
+    `  Suggestion for next /100x:learn revision of ${driftedName}:`,
     `    ADD content that reinforces ${driftedName}'s historically-owned cognitive patterns.`,
     `    DO NOT remove shared content \u2014 removing shared boilerplate lowers Jaccard arithmetically`,
     `    but does not restore identity differentiation.`,
@@ -53485,7 +53896,7 @@ function registerFlywheelDiversityCheck(parent) {
     const personas = /* @__PURE__ */ new Map();
     for (const filepath of files) {
       try {
-        const body = readFileSync102(filepath, "utf8");
+        const body = readFileSync104(filepath, "utf8");
         if (body.trim().length > 0) {
           personas.set(basename15(filepath, ".md"), body);
         }
@@ -53516,9 +53927,9 @@ ${formatRedivergencePrompt(persona_a, persona_b, score, void 0, void 0, threshol
 }
 
 // src/commands/flywheel/ping.ts
-import { mkdirSync as mkdirSync68, writeFileSync as writeFileSync61 } from "node:fs";
-import { homedir as homedir70 } from "node:os";
-import { dirname as dirname65, join as join114 } from "node:path";
+import { mkdirSync as mkdirSync69, writeFileSync as writeFileSync63 } from "node:fs";
+import { homedir as homedir71 } from "node:os";
+import { dirname as dirname66, join as join115 } from "node:path";
 var COLD_START_BUDGET_GOOD_MS = 200;
 var COLD_START_BUDGET_FAIR_MS = 500;
 function classifyColdStart(coldStartMs) {
@@ -53534,9 +53945,9 @@ function readOlamVersion() {
   }
 }
 function writeBaseline(record) {
-  const baselinePath = join114(homedir70(), ".local", "share", "olam", "flywheel-baseline.json");
-  mkdirSync68(dirname65(baselinePath), { recursive: true });
-  writeFileSync61(baselinePath, JSON.stringify(record, null, 2) + "\n", "utf8");
+  const baselinePath = join115(homedir71(), ".local", "share", "olam", "flywheel-baseline.json");
+  mkdirSync69(dirname66(baselinePath), { recursive: true });
+  writeFileSync63(baselinePath, JSON.stringify(record, null, 2) + "\n", "utf8");
   return baselinePath;
 }
 function registerFlywheelPing(parent) {
@@ -53576,16 +53987,16 @@ init_skill_sources();
 init_prefix_rules();
 import {
   copyFileSync as copyFileSync15,
-  existsSync as existsSync116,
-  mkdirSync as mkdirSync69,
-  readFileSync as readFileSync103,
+  existsSync as existsSync118,
+  mkdirSync as mkdirSync70,
+  readFileSync as readFileSync105,
   readdirSync as readdirSync33,
   statSync as statSync33,
-  writeFileSync as writeFileSync62
+  writeFileSync as writeFileSync64
 } from "node:fs";
 import { spawnSync as spawnSync32 } from "node:child_process";
-import { homedir as homedir71 } from "node:os";
-import { dirname as dirname66, join as join115, relative as relative7 } from "node:path";
+import { homedir as homedir72 } from "node:os";
+import { dirname as dirname67, join as join116, relative as relative7 } from "node:path";
 function escapeRegex(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -53622,7 +54033,7 @@ function walkOverlayFiles(dir) {
     return [];
   }
   for (const entry of entries) {
-    const fullPath = join115(dir, entry);
+    const fullPath = join116(dir, entry);
     let stat;
     try {
       stat = statSync33(fullPath);
@@ -53661,10 +54072,10 @@ function resolveAtlasUser2(opts) {
     assertValidAtlasUser(v);
     return v;
   }
-  const claudeDir2 = opts._testClaudeDir ?? process.env["OLAM_CLAUDE_DIR"] ?? join115(homedir71(), ".claude");
-  const f = join115(claudeDir2, ".atlas-user");
-  if (existsSync116(f)) {
-    const v = readFileSync103(f, "utf-8").trim();
+  const claudeDir2 = opts._testClaudeDir ?? process.env["OLAM_CLAUDE_DIR"] ?? join116(homedir72(), ".claude");
+  const f = join116(claudeDir2, ".atlas-user");
+  if (existsSync118(f)) {
+    const v = readFileSync105(f, "utf-8").trim();
     if (v.length === 0) return null;
     assertValidAtlasUser(v);
     return v;
@@ -53686,8 +54097,8 @@ function runGit2(args, cwd) {
 function walkPushSourceFiles(claudeDir2) {
   const result = [];
   const roots = [
-    { dir: join115(claudeDir2, "skills.overrides"), overlayKind: "skills" },
-    { dir: join115(claudeDir2, "agents.overrides"), overlayKind: "agents" }
+    { dir: join116(claudeDir2, "skills.overrides"), overlayKind: "skills" },
+    { dir: join116(claudeDir2, "agents.overrides"), overlayKind: "agents" }
   ];
   for (const { dir, overlayKind } of roots) {
     const files = walkOverlayFiles(dir);
@@ -53798,7 +54209,7 @@ function pushOverlays(opts) {
   Run \`olam skills atlas-user set <name>\` to configure your atlas user.`
     );
   }
-  const claudeDir2 = opts._testClaudeDir ?? opts.targetDir ?? process.env["OLAM_CLAUDE_DIR"] ?? join115(homedir71(), ".claude");
+  const claudeDir2 = opts._testClaudeDir ?? opts.targetDir ?? process.env["OLAM_CLAUDE_DIR"] ?? join116(homedir72(), ".claude");
   const sourceFiles = walkPushSourceFiles(claudeDir2);
   const registeredPrefixes = (opts._testSkillSources ?? listSkillSources()).map((s) => s.prefix).filter((p) => typeof p === "string" && p.length > 0);
   if (registeredPrefixes.length > 0) {
@@ -53806,7 +54217,7 @@ function pushOverlays(opts) {
       const basename17 = relPath.split("/").pop() ?? relPath;
       let content;
       try {
-        content = readFileSync103(srcFile);
+        content = readFileSync105(srcFile);
       } catch {
         continue;
       }
@@ -53845,21 +54256,21 @@ function pushOverlays(opts) {
 ` + preflightWarnings.map((w) => `  - ${w.split("\n")[0]}`).join("\n") + "\n"
       );
     }
-    const membersBase2 = join115(clonePath, "members", atlasUser);
+    const membersBase2 = join116(clonePath, "members", atlasUser);
     let wouldCopy = 0;
     let wouldUnchange = 0;
     let wouldCreate = 0;
     for (const { srcFile, overlayKind, relPath } of sourceFiles) {
-      const targetDir = join115(membersBase2, `${overlayKind}.overrides`);
-      const targetFile = join115(targetDir, relPath);
+      const targetDir = join116(membersBase2, `${overlayKind}.overrides`);
+      const targetFile = join116(targetDir, relPath);
       let srcBuf;
       try {
-        srcBuf = readFileSync103(srcFile);
+        srcBuf = readFileSync105(srcFile);
       } catch {
         continue;
       }
-      if (existsSync116(targetFile)) {
-        const dstBuf = readFileSync103(targetFile);
+      if (existsSync118(targetFile)) {
+        const dstBuf = readFileSync105(targetFile);
         if (srcBuf.equals(dstBuf)) {
           wouldUnchange += 1;
           process.stdout.write(`  [skip] ${overlayKind}.overrides/${relPath} (unchanged)
@@ -53900,32 +54311,32 @@ function pushOverlays(opts) {
       `failed to create branch "${branchName}": ${err instanceof Error ? err.message : String(err)}`
     );
   }
-  const membersBase = join115(clonePath, "members", atlasUser);
+  const membersBase = join116(clonePath, "members", atlasUser);
   let filesCopied = 0;
   let filesUnchanged = 0;
   let filesCreated = 0;
   try {
     for (const { srcFile, overlayKind, relPath } of sourceFiles) {
-      const targetDir = join115(membersBase, `${overlayKind}.overrides`, dirname66(relPath));
-      const targetFile = join115(membersBase, `${overlayKind}.overrides`, relPath);
+      const targetDir = join116(membersBase, `${overlayKind}.overrides`, dirname67(relPath));
+      const targetFile = join116(membersBase, `${overlayKind}.overrides`, relPath);
       let srcBuf;
       try {
-        srcBuf = readFileSync103(srcFile);
+        srcBuf = readFileSync105(srcFile);
       } catch {
         continue;
       }
-      const targetExists = existsSync116(targetFile);
+      const targetExists = existsSync118(targetFile);
       if (targetExists) {
-        const dstBuf = readFileSync103(targetFile);
+        const dstBuf = readFileSync105(targetFile);
         if (srcBuf.equals(dstBuf)) {
           filesUnchanged += 1;
           continue;
         }
-        mkdirSync69(targetDir, { recursive: true });
+        mkdirSync70(targetDir, { recursive: true });
         copyFileSync15(srcFile, targetFile);
         filesCopied += 1;
       } else {
-        mkdirSync69(targetDir, { recursive: true });
+        mkdirSync70(targetDir, { recursive: true });
         copyFileSync15(srcFile, targetFile);
         filesCreated += 1;
       }
@@ -53993,8 +54404,8 @@ function initMember(opts) {
     clonePath = skillSourceClonePath(source.id);
   }
   const atlasUser = resolveAtlasUser2(opts) ?? memberName;
-  const memberDir = join115(clonePath, "members", memberName);
-  if (existsSync116(memberDir)) {
+  const memberDir = join116(clonePath, "members", memberName);
+  if (existsSync118(memberDir)) {
     throw new PushError(
       1,
       `members/${memberName}/ already exists; use --push to update; or remove manually first
@@ -54002,9 +54413,9 @@ function initMember(opts) {
     );
   }
   const wouldCreate = [
-    join115(memberDir, "skills.overrides", ".gitkeep"),
-    join115(memberDir, "agents.overrides", ".gitkeep"),
-    join115(memberDir, "README.md")
+    join116(memberDir, "skills.overrides", ".gitkeep"),
+    join116(memberDir, "agents.overrides", ".gitkeep"),
+    join116(memberDir, "README.md")
   ];
   if (opts.dryRun === true) {
     const { preflightWarnings } = runPreFlight(clonePath, opts.forceCurrentBranch === true, true);
@@ -54060,12 +54471,12 @@ function initMember(opts) {
     );
   }
   try {
-    mkdirSync69(join115(memberDir, "skills.overrides"), { recursive: true });
-    writeFileSync62(join115(memberDir, "skills.overrides", ".gitkeep"), "");
-    mkdirSync69(join115(memberDir, "agents.overrides"), { recursive: true });
-    writeFileSync62(join115(memberDir, "agents.overrides", ".gitkeep"), "");
-    writeFileSync62(
-      join115(memberDir, "README.md"),
+    mkdirSync70(join116(memberDir, "skills.overrides"), { recursive: true });
+    writeFileSync64(join116(memberDir, "skills.overrides", ".gitkeep"), "");
+    mkdirSync70(join116(memberDir, "agents.overrides"), { recursive: true });
+    writeFileSync64(join116(memberDir, "agents.overrides", ".gitkeep"), "");
+    writeFileSync64(
+      join116(memberDir, "README.md"),
       `# Member overlays for \`${memberName}\`
 
 See docs/plans/member-overlays-sync/ for layer architecture.
@@ -54106,10 +54517,10 @@ Next steps (run in ${clonePath}):`,
   };
 }
 function migrateOverlays(opts = {}) {
-  const root = opts.targetDir ?? join115(homedir71(), ".claude");
+  const root = opts.targetDir ?? join116(homedir72(), ".claude");
   const overrideRoots = [
-    join115(root, "skills.overrides"),
-    join115(root, "agents.overrides")
+    join116(root, "skills.overrides"),
+    join116(root, "agents.overrides")
   ];
   const allFiles = [];
   for (const overrideRoot of overrideRoots) {
@@ -54125,7 +54536,7 @@ function migrateOverlays(opts = {}) {
   for (const filePath of allFiles) {
     let original;
     try {
-      original = readFileSync103(filePath, "utf8");
+      original = readFileSync105(filePath, "utf8");
     } catch {
       continue;
     }
@@ -54136,7 +54547,7 @@ function migrateOverlays(opts = {}) {
       continue;
     }
     if (opts.dryRun !== true) {
-      writeFileSync62(filePath, newContent, "utf8");
+      writeFileSync64(filePath, newContent, "utf8");
     }
     summary2.modified += 1;
     summary2.totalReplacements += totalReplacements;
@@ -54228,7 +54639,7 @@ function registerFlywheelMigrateOverlays(parent) {
       }
       return;
     }
-    const root = opts.targetDir ?? join115(homedir71(), ".claude");
+    const root = opts.targetDir ?? join116(homedir72(), ".claude");
     const summary2 = migrateOverlays(opts);
     if (opts.json === true) {
       process.stdout.write(JSON.stringify(summary2, null, 2) + "\n");
@@ -54267,9 +54678,9 @@ Per-file changes:
 }
 
 // src/commands/flywheel/session-start.ts
-import { readFileSync as readFileSync104, statSync as statSync34 } from "node:fs";
-import { homedir as homedir72 } from "node:os";
-import { join as join116 } from "node:path";
+import { readFileSync as readFileSync106, statSync as statSync34 } from "node:fs";
+import { homedir as homedir73 } from "node:os";
+import { join as join117 } from "node:path";
 var SESSIONSTART_HOOK_SENTINEL = "olam-sessionstart-context-hook-v1";
 var MAX_WAKE_BRIEF_BYTES = 8 * 1024;
 var MAX_ACTIVE_WORLD_BYTES = 4 * 1024;
@@ -54285,7 +54696,7 @@ function tryReadCapped(path106, maxBytes) {
       );
       return null;
     }
-    return readFileSync104(path106, "utf-8");
+    return readFileSync106(path106, "utf-8");
   } catch (err) {
     const code = err?.code;
     if (code === "ENOENT") return null;
@@ -54310,15 +54721,15 @@ function tryParseJson(raw, label) {
 }
 function buildContextBlock(olamHome6) {
   const config = tryParseJson(
-    tryReadCapped(join116(olamHome6, "config.json"), MAX_CONFIG_BYTES),
+    tryReadCapped(join117(olamHome6, "config.json"), MAX_CONFIG_BYTES),
     "config.json"
   );
   const activeWorld = tryParseJson(
-    tryReadCapped(join116(olamHome6, "state", "active-world.json"), MAX_ACTIVE_WORLD_BYTES),
+    tryReadCapped(join117(olamHome6, "state", "active-world.json"), MAX_ACTIVE_WORLD_BYTES),
     "active-world.json"
   );
   const wakeBrief = tryReadCapped(
-    join116(olamHome6, "state", "wake-brief.md"),
+    join117(olamHome6, "state", "wake-brief.md"),
     MAX_WAKE_BRIEF_BYTES
   );
   const sections = [];
@@ -54370,7 +54781,7 @@ function registerFlywheelSessionStart(parent) {
   parent.command("session-start").description(
     "Emit operator-state context for the SessionStart hook (4th defense layer). Reads ~/.olam/state/* and writes the additionalContext JSON to stdout. Fail-soft: always exits 0."
   ).action(() => {
-    const olamHome6 = process.env.OLAM_HOME ?? join116(homedir72(), ".olam");
+    const olamHome6 = process.env.OLAM_HOME ?? join117(homedir73(), ".olam");
     emitSessionStartContext(olamHome6);
     process.exit(0);
   });
@@ -54379,9 +54790,9 @@ function registerFlywheelSessionStart(parent) {
 // src/commands/flywheel/install-sessionstart-hook.ts
 init_merge_settings();
 init_output();
-import { existsSync as existsSync117, copyFileSync as copyFileSync16, mkdirSync as mkdirSync70, readFileSync as readFileSync105, unlinkSync as unlinkSync25, writeFileSync as writeFileSync63 } from "node:fs";
-import { homedir as homedir73 } from "node:os";
-import { dirname as dirname67, join as join117 } from "node:path";
+import { existsSync as existsSync119, copyFileSync as copyFileSync16, mkdirSync as mkdirSync71, readFileSync as readFileSync107, unlinkSync as unlinkSync25, writeFileSync as writeFileSync65 } from "node:fs";
+import { homedir as homedir74 } from "node:os";
+import { dirname as dirname68, join as join118 } from "node:path";
 var SESSIONSTART_HOOK_STAGE = "SessionStart";
 var SESSIONSTART_HOOK_TIMEOUT_MS = 5e3;
 var NOOP_GUARD = "command -v olam >/dev/null 2>&1 || exit 0;";
@@ -54398,18 +54809,18 @@ function buildSessionStartHookEntry() {
   };
 }
 function settingsPathFor4(scope, cwd) {
-  if (scope === "user") return join117(homedir73(), ".claude", "settings.json");
-  return join117(cwd ?? process.cwd(), ".claude", "settings.json");
+  if (scope === "user") return join118(homedir74(), ".claude", "settings.json");
+  return join118(cwd ?? process.cwd(), ".claude", "settings.json");
 }
 function backup3(filePath) {
-  if (!existsSync117(filePath)) return null;
+  if (!existsSync119(filePath)) return null;
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
   const backupPath = `${filePath}.olam-bak.${ts}`;
   copyFileSync16(filePath, backupPath);
   return backupPath;
 }
 function installSessionStartHook(filePath) {
-  mkdirSync70(dirname67(filePath), { recursive: true });
+  mkdirSync71(dirname68(filePath), { recursive: true });
   const backupPath = backup3(filePath);
   const result = mergeHomeSettingsJson(filePath, {
     ensureHook: {
@@ -54428,8 +54839,8 @@ function installSessionStartHook(filePath) {
   return { status: result.status, filePath, backupPath };
 }
 function uninstallSessionStartHook(filePath) {
-  if (!existsSync117(filePath)) return { status: "no-settings", filePath };
-  const raw = readFileSync105(filePath, "utf-8");
+  if (!existsSync119(filePath)) return { status: "no-settings", filePath };
+  const raw = readFileSync107(filePath, "utf-8");
   const settings = raw.trim() ? JSON.parse(raw) : {};
   const matchers = settings.hooks?.SessionStart;
   if (!Array.isArray(matchers) || matchers.length === 0) {
@@ -54469,7 +54880,7 @@ function uninstallSessionStartHook(filePath) {
       delete next.hooks.SessionStart;
     }
   }
-  writeFileSync63(filePath, JSON.stringify(next, null, 2) + "\n");
+  writeFileSync65(filePath, JSON.stringify(next, null, 2) + "\n");
   return { status: "removed", filePath };
 }
 function registerFlywheelInstallSessionStartHook(parent) {
@@ -54787,7 +55198,7 @@ init_manager();
 init_context();
 init_output();
 import { spawnSync as defaultSpawnSync } from "node:child_process";
-import * as fs104 from "node:fs";
+import * as fs105 from "node:fs";
 import * as os58 from "node:os";
 import * as path103 from "node:path";
 function devboxContainerName(worldId) {
@@ -54807,8 +55218,8 @@ function defaultRestartContainer(name, spawn14 = defaultSpawnSync) {
   };
 }
 function defaultAppendAuditLog(homeDir, line) {
-  fs104.mkdirSync(homeDir, { recursive: true });
-  fs104.appendFileSync(path103.join(homeDir, "usage.log"), line.endsWith("\n") ? line : line + "\n", {
+  fs105.mkdirSync(homeDir, { recursive: true });
+  fs105.appendFileSync(path103.join(homeDir, "usage.log"), line.endsWith("\n") ? line : line + "\n", {
     encoding: "utf-8"
   });
 }
@@ -54854,18 +55265,18 @@ async function doRekey(worldId, deps) {
   const rotatedAt = deps.now().toISOString();
   const homeDir = deps.olamHomeDir();
   const worldDir = path103.join(homeDir, "worlds", worldId);
-  fs104.mkdirSync(worldDir, { recursive: true });
+  fs105.mkdirSync(worldDir, { recursive: true });
   const credentialsPath = path103.join(worldDir, "credentials.json");
   const payload = {
     worldRoleName,
     password,
     rotatedAt
   };
-  fs104.writeFileSync(credentialsPath, JSON.stringify(payload, null, 2) + "\n", {
+  fs105.writeFileSync(credentialsPath, JSON.stringify(payload, null, 2) + "\n", {
     encoding: "utf-8",
     mode: 384
   });
-  fs104.chmodSync(credentialsPath, 384);
+  fs105.chmodSync(credentialsPath, 384);
   const restart = deps.restartContainer(devboxContainerName(worldId));
   deps.appendAuditLog(`${rotatedAt} ${worldId} rekey`);
   if (!restart.ok) {
@@ -54931,7 +55342,7 @@ function registerRekey(program2) {
 // src/commands/yolo.ts
 init_output();
 import * as childProcess2 from "node:child_process";
-import * as fs105 from "node:fs";
+import * as fs106 from "node:fs";
 import * as os59 from "node:os";
 import * as path104 from "node:path";
 import pc49 from "picocolors";
@@ -54956,12 +55367,12 @@ function defaultRunner(cmd, args, opts) {
   };
 }
 function defaultSleeper(ms) {
-  return new Promise((resolve30) => setTimeout(resolve30, ms));
+  return new Promise((resolve31) => setTimeout(resolve31, ms));
 }
 function detectTmuxBinary(runner = defaultRunner) {
   for (const p of TMUX_PROBE_PATHS) {
     if (TMUX_SHIM_MARKERS.some((m) => p.includes(m))) continue;
-    if (fs105.existsSync(p)) return p;
+    if (fs106.existsSync(p)) return p;
   }
   const result = runner("which", ["tmux"]);
   if (result.status === 0 && result.stdout) {
@@ -54976,8 +55387,8 @@ function resolveWorktreeRoot(runner = defaultRunner, cwd = process.cwd()) {
     return process.env["OLAM_TMUX_YOLO_ROOT"];
   }
   const rootFile = path104.join(os59.homedir(), ".olam-tmux-yolo-root");
-  if (fs105.existsSync(rootFile)) {
-    const line = fs105.readFileSync(rootFile, "utf-8").trim();
+  if (fs106.existsSync(rootFile)) {
+    const line = fs106.readFileSync(rootFile, "utf-8").trim();
     if (line) return line;
   }
   const gitResult = runner("git", ["rev-parse", "--show-toplevel"], { cwd });
@@ -55011,7 +55422,7 @@ async function spawnYolo(opts) {
     );
   }
   try {
-    fs105.accessSync(opts.promptFile, fs105.constants.R_OK);
+    fs106.accessSync(opts.promptFile, fs106.constants.R_OK);
   } catch {
     throw new Error(
       `Prompt file not found or not readable: ${opts.promptFile}
@@ -55027,7 +55438,7 @@ Create the file with your task description and try again.`
 Run: olam yolo --cleanup ${opts.name}  (or use --force to bypass the merged check)`
     );
   }
-  if (fs105.existsSync(worktreePath)) {
+  if (fs106.existsSync(worktreePath)) {
     throw new Error(
       `Worktree directory already exists: ${worktreePath}
 Run: olam yolo --cleanup ${opts.name}  to remove it first.`
@@ -55095,7 +55506,7 @@ function listYoloWindows(opts = {}) {
     const worktreePath = path104.join(worktreeRoot, name);
     return {
       name,
-      worktreePath: fs105.existsSync(worktreePath) ? worktreePath : void 0
+      worktreePath: fs106.existsSync(worktreePath) ? worktreePath : void 0
     };
   });
 }
@@ -55229,18 +55640,18 @@ function registerYolo(program2) {
 }
 
 // src/pleri-config.ts
-import * as fs106 from "node:fs";
+import * as fs107 from "node:fs";
 import * as path105 from "node:path";
 function isPleriConfigured(configDir = process.env.OLAM_CONFIG_DIR ?? ".olam") {
   if (process.env.PLERI_BASE_URL) {
     return true;
   }
   const configPath = path105.join(configDir, "config.yaml");
-  if (!fs106.existsSync(configPath)) {
+  if (!fs107.existsSync(configPath)) {
     return false;
   }
   try {
-    const contents = fs106.readFileSync(configPath, "utf8");
+    const contents = fs107.readFileSync(configPath, "utf8");
     return /^[^#\n]*\bpleri:/m.test(contents);
   } catch {
     return false;
@@ -55279,7 +55690,7 @@ var HELP_GROUPS = [
   },
   {
     title: "Skills & knowledge",
-    names: ["skills", "kg", "ask", "flywheel"]
+    names: ["skills", "100x", "kg", "ask", "flywheel"]
   },
   {
     title: "Substrate & infra",
@@ -55442,7 +55853,7 @@ registerSkillsMigrateHooks(program);
 registerSkillsMigrateHooksBack(program);
 registerSkillsShadowBackups(program);
 registerSkillsDoctor(program);
-registerSkills10x(program);
+registerSkills100x(program);
 registerHermes(program);
 void scheduleUpgradeCheck(cliVersion);
 await program.parseAsync();