@pleri/olam-cli 0.1.81 → 0.1.83

package/dist/index.js

@@ -487,8 +487,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path48, errorMaps, issueData } = params;
-      const fullPath = [...path48, ...issueData.path || []];
+      const { data, path: path49, errorMaps, issueData } = params;
+      const fullPath = [...path49, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -796,11 +796,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path48, key) {
+      constructor(parent, value, path49, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path48;
+        this._path = path49;
         this._key = key;
       }
       get path() {
@@ -4281,7 +4281,7 @@ import YAML from "yaml";
 function bootstrapStepCmd(entry) {
   return typeof entry === "string" ? entry : entry.cmd;
 }
-function refineForbiddenKeys(value, path48, ctx, rejectSource) {
+function refineForbiddenKeys(value, path49, ctx, rejectSource) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return;
   }
@@ -4289,12 +4289,12 @@ function refineForbiddenKeys(value, path48, ctx, rejectSource) {
     if (FORBIDDEN_KEYS.has(key)) {
       ctx.addIssue({
         code: external_exports.ZodIssueCode.custom,
-        path: [...path48, key],
+        path: [...path49, key],
         message: `forbidden key "${key}" (prototype-pollution surface)`
       });
       continue;
     }
-    if (rejectSource && path48.length === 0 && key === "source") {
+    if (rejectSource && path49.length === 0 && key === "source") {
       ctx.addIssue({
         code: external_exports.ZodIssueCode.custom,
         path: ["source"],
@@ -4302,21 +4302,21 @@ function refineForbiddenKeys(value, path48, ctx, rejectSource) {
       });
       continue;
     }
-    refineForbiddenKeys(value[key], [...path48, key], ctx, false);
+    refineForbiddenKeys(value[key], [...path49, key], ctx, false);
   }
 }
-function rejectForbiddenKeys(value, path48, rejectSource) {
+function rejectForbiddenKeys(value, path49, rejectSource) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return;
   }
   for (const key of Object.keys(value)) {
     if (FORBIDDEN_KEYS.has(key)) {
-      throw new Error(`[manifest] ${path48}: forbidden key "${key}" (prototype-pollution surface)`);
+      throw new Error(`[manifest] ${path49}: forbidden key "${key}" (prototype-pollution surface)`);
     }
     if (rejectSource && key === "source") {
-      throw new Error(`[manifest] ${path48}: top-level "source" is loader-stamped \u2014 manifests must not author it`);
+      throw new Error(`[manifest] ${path49}: top-level "source" is loader-stamped \u2014 manifests must not author it`);
     }
-    rejectForbiddenKeys(value[key], `${path48}.${key}`, false);
+    rejectForbiddenKeys(value[key], `${path49}.${key}`, false);
   }
 }
 function unknownTopLevelKeys(parsed) {
@@ -5309,8 +5309,8 @@ var init_client = __esm({
           throw new Error(`failed to report rate-limit for ${accountId} (HTTP ${res.status})`);
         }
       }
-      async request(method, path48, body, attempt = 0) {
-        const url = `${this.baseUrl}${path48}`;
+      async request(method, path49, body, attempt = 0) {
+        const url = `${this.baseUrl}${path49}`;
         const controller = new AbortController();
         const timer = setTimeout(() => controller.abort(), this.timeoutMs);
         const headers = {};
@@ -5328,7 +5328,7 @@ var init_client = __esm({
         } catch (err) {
           if (attempt < RETRY_COUNT && isTransient(err)) {
             await sleep(RETRY_BACKOFF_MS * (attempt + 1));
-            return this.request(method, path48, body, attempt + 1);
+            return this.request(method, path49, body, attempt + 1);
           }
           throw err;
         } finally {
@@ -6819,8 +6819,8 @@ var init_provider3 = __esm({
       // -----------------------------------------------------------------------
       // Internal fetch helper
       // -----------------------------------------------------------------------
-      async request(path48, method, body) {
-        const url = `${this.config.workerUrl}${path48}`;
+      async request(path49, method, body) {
+        const url = `${this.config.workerUrl}${path49}`;
         const bearer = await this.config.mintToken();
         const headers = {
           Authorization: `Bearer ${bearer}`
@@ -8112,8 +8112,8 @@ import { execFileSync as execFileSync3 } from "node:child_process";
 import * as fs14 from "node:fs";
 import * as os9 from "node:os";
 import * as path15 from "node:path";
-function expandHome(p, homedir25) {
-  return p.replace(/^~(?=$|\/|\\)/, homedir25());
+function expandHome(p, homedir26) {
+  return p.replace(/^~(?=$|\/|\\)/, homedir26());
 }
 function sanitizeRepoFilename(name) {
   const sanitized = name.replace(/[^A-Za-z0-9._-]/g, "_");
@@ -8136,7 +8136,7 @@ ${stderr}`;
 }
 function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
   const exec = deps.exec ?? ((cmd, args, opts) => execFileSync3(cmd, args, opts));
-  const homedir25 = deps.homedir ?? (() => os9.homedir());
+  const homedir26 = deps.homedir ?? (() => os9.homedir());
   const baselineDir = path15.join(workspacePath, ".olam", "baseline");
   try {
     fs14.mkdirSync(baselineDir, { recursive: true });
@@ -8152,7 +8152,7 @@ function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
       continue;
     const filename = `${sanitizeRepoFilename(repo.name)}.diff`;
     const outPath = path15.join(baselineDir, filename);
-    const repoPath = expandHome(repo.path, homedir25);
+    const repoPath = expandHome(repo.path, homedir26);
     if (!fs14.existsSync(repoPath)) {
       writeBaselineFile(outPath, `# repo: ${repo.name}
 # (skipped: path ${repoPath} does not exist)
@@ -13674,10 +13674,10 @@ async function readHostCpToken2() {
   if (!fs25.existsSync(tp)) return null;
   return fs25.readFileSync(tp, "utf-8").trim();
 }
-async function callHostCpProxy(method, worldId, path48, body) {
+async function callHostCpProxy(method, worldId, path49, body) {
   const token = await readHostCpToken2();
   if (!token) return { ok: false, status: 0, error: "no token (host CP not started)" };
-  const url = `http://127.0.0.1:${HOST_CP_PORT}/api/world/${encodeURIComponent(worldId)}${path48}`;
+  const url = `http://127.0.0.1:${HOST_CP_PORT}/api/world/${encodeURIComponent(worldId)}${path49}`;
   try {
     const headers = {
       Authorization: `Bearer ${token}`
@@ -14136,16 +14136,16 @@ __export(machine_schema_exports, {
   readMachineConfig: () => readMachineConfig,
   writeMachineConfig: () => writeMachineConfig
 });
-import * as fs40 from "node:fs";
-import * as path43 from "node:path";
-import * as os23 from "node:os";
+import * as fs41 from "node:fs";
+import * as path44 from "node:path";
+import * as os24 from "node:os";
 import { parse as parseYaml5, stringify as stringifyYaml5 } from "yaml";
 function readMachineConfig(configPath) {
   const p = configPath ?? DEFAULT_CONFIG_PATH;
-  if (!fs40.existsSync(p))
+  if (!fs41.existsSync(p))
     return null;
   try {
-    const raw = fs40.readFileSync(p, "utf-8");
+    const raw = fs41.readFileSync(p, "utf-8");
     const parsed = parseYaml5(raw);
     return MachineConfigSchema.parse(parsed);
   } catch {
@@ -14154,8 +14154,8 @@ function readMachineConfig(configPath) {
 }
 function writeMachineConfig(config, configPath) {
   const p = configPath ?? DEFAULT_CONFIG_PATH;
-  fs40.mkdirSync(path43.dirname(p), { recursive: true });
-  fs40.writeFileSync(p, stringifyYaml5({ ...config }), { mode: 420 });
+  fs41.mkdirSync(path44.dirname(p), { recursive: true });
+  fs41.writeFileSync(p, stringifyYaml5({ ...config }), { mode: 420 });
 }
 function initMachineConfig(opts = {}) {
   const configPath = opts.configPath ?? DEFAULT_CONFIG_PATH;
@@ -14178,9 +14178,9 @@ var init_machine_schema = __esm({
       channel: external_exports.enum(["stable", "beta", "edge"]).default("stable"),
       auto_update: external_exports.boolean().default(true),
       telemetry: external_exports.boolean().default(true),
-      worlds_dir: external_exports.string().default(() => path43.join(os23.homedir(), ".olam", "worlds"))
+      worlds_dir: external_exports.string().default(() => path44.join(os24.homedir(), ".olam", "worlds"))
     });
-    DEFAULT_CONFIG_PATH = path43.join(os23.homedir(), ".olam", "config.yaml");
+    DEFAULT_CONFIG_PATH = path44.join(os24.homedir(), ".olam", "config.yaml");
   }
 });
 
@@ -14562,9 +14562,9 @@ var UnknownArchetypeError = class extends Error {
 };
 var ArchetypeCycleError = class extends Error {
   path;
-  constructor(path48) {
-    super(`Archetype inheritance cycle detected: ${path48.join(" \u2192 ")} \u2192 ${path48[0] ?? "?"}`);
-    this.path = path48;
+  constructor(path49) {
+    super(`Archetype inheritance cycle detected: ${path49.join(" \u2192 ")} \u2192 ${path49[0] ?? "?"}`);
+    this.path = path49;
     this.name = "ArchetypeCycleError";
   }
 };
@@ -15196,8 +15196,8 @@ function runStep(label, cmd, args, opts = {}) {
 }
 async function confirm(message) {
   if (!process.stdin.isTTY) return true;
-  const { createInterface: createInterface4 } = await import("node:readline");
-  const rl = createInterface4({ input: process.stdin, output: process.stdout });
+  const { createInterface: createInterface5 } = await import("node:readline");
+  const rl = createInterface5({ input: process.stdin, output: process.stdout });
   return new Promise((resolve10) => {
     rl.question(`${message} [y/N] `, (answer) => {
       rl.close();
@@ -15929,9 +15929,9 @@ function formatFreshnessWarning(result, image = DEFAULT_DEVBOX_IMAGE) {
     "These source files have changed since the image was built; the",
     "changes will NOT take effect in fresh worlds until you rebuild:"
   ];
-  for (const { path: path48, mtimeMs } of result.newerSources) {
+  for (const { path: path49, mtimeMs } of result.newerSources) {
     const when = new Date(mtimeMs).toISOString();
-    lines.push(`  \u2022 ${path48}  (modified ${when})`);
+    lines.push(`  \u2022 ${path49}  (modified ${when})`);
   }
   lines.push("");
   lines.push("Rebuild with:");
@@ -16090,15 +16090,15 @@ init_host_cp();
 var HOST_CP_URL = "http://127.0.0.1:19000";
 async function readHostCpTokenForCreate() {
   try {
-    const { default: fs46 } = await import("node:fs");
-    const { default: os27 } = await import("node:os");
-    const { default: path48 } = await import("node:path");
-    const tp = path48.join(
-      process.env.OLAM_HOME ?? path48.join(os27.homedir(), ".olam"),
+    const { default: fs47 } = await import("node:fs");
+    const { default: os28 } = await import("node:os");
+    const { default: path49 } = await import("node:path");
+    const tp = path49.join(
+      process.env.OLAM_HOME ?? path49.join(os28.homedir(), ".olam"),
       "host-cp.token"
     );
-    if (!fs46.existsSync(tp)) return null;
-    return fs46.readFileSync(tp, "utf-8").trim();
+    if (!fs47.existsSync(tp)) return null;
+    return fs47.readFileSync(tp, "utf-8").trim();
   } catch {
     return null;
   }
@@ -16461,12 +16461,12 @@ function defaultNameFromPrompt(prompt) {
 }
 async function readHostCpToken3() {
   try {
-    const { default: fs46 } = await import("node:fs");
-    const { default: os27 } = await import("node:os");
-    const { default: path48 } = await import("node:path");
-    const tp = path48.join(os27.homedir(), ".olam", "host-cp.token");
-    if (!fs46.existsSync(tp)) return null;
-    const raw = fs46.readFileSync(tp, "utf-8").trim();
+    const { default: fs47 } = await import("node:fs");
+    const { default: os28 } = await import("node:os");
+    const { default: path49 } = await import("node:path");
+    const tp = path49.join(os28.homedir(), ".olam", "host-cp.token");
+    if (!fs47.existsSync(tp)) return null;
+    const raw = fs47.readFileSync(tp, "utf-8").trim();
     return raw.length > 0 ? raw : null;
   } catch {
     return null;
@@ -17149,11 +17149,381 @@ async function confirmInteractive() {
   });
 }
 
+// src/commands/implode.ts
+init_output();
+import { execFileSync as execFileSync7 } from "node:child_process";
+import * as fs30 from "node:fs";
+import * as os18 from "node:os";
+import * as path32 from "node:path";
+import { createInterface as createInterface2 } from "node:readline/promises";
+import pc14 from "picocolors";
+var NPM_PACKAGE = "@pleri/olam-cli";
+var realExec = (cmd, args) => {
+  try {
+    const stdout = execFileSync7(cmd, [...args], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return { exitCode: 0, stdout, stderr: "" };
+  } catch (err) {
+    const e = err;
+    return {
+      exitCode: e.status ?? 1,
+      stdout: typeof e.stdout === "string" ? e.stdout : e.stdout?.toString("utf-8") ?? "",
+      stderr: typeof e.stderr === "string" ? e.stderr : e.stderr?.toString("utf-8") ?? ""
+    };
+  }
+};
+function surveyOlam(opts = {}) {
+  const exec = opts.exec ?? realExec;
+  const home = opts.olamHome ?? path32.join(os18.homedir(), ".olam");
+  const containers = listDocker(exec, ["ps", "-a", "--format", "{{.Names}}"]).filter(
+    (n) => n.startsWith("olam-")
+  );
+  const images = listDocker(exec, ["images", "--format", "{{.Repository}}:{{.Tag}}"]).filter(
+    (ref) => ref.startsWith("olam-") || ref.startsWith("ghcr.io/pleri/olam-") || ref.startsWith("ghcr.io/pleri/olam")
+  );
+  const volumes = listDocker(exec, ["volume", "ls", "--format", "{{.Name}}"]).filter(
+    (n) => n.startsWith("olam-")
+  );
+  const networks = listDocker(exec, ["network", "ls", "--format", "{{.Name}}"]).filter(
+    (n) => n.startsWith("olam-") && n !== "olam-host-cp-internal-default"
+  );
+  const worlds = [];
+  const worldsDir = path32.join(home, "worlds");
+  if (fs30.existsSync(worldsDir)) {
+    for (const entry of fs30.readdirSync(worldsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const wPath = path32.join(worldsDir, entry.name);
+      const bytes = dirSize(wPath);
+      const { dirty, note } = inspectWorldGitState(wPath);
+      worlds.push({ id: entry.name, bytes, dirty, note, path: wPath });
+    }
+  }
+  const homeBytesNonWorld = fs30.existsSync(home) ? Math.max(0, dirSize(home) - worlds.reduce((acc, w) => acc + w.bytes, 0)) : 0;
+  const npmRoot = exec("npm", ["root", "-g"]);
+  const npmGlobalRoot = npmRoot.exitCode === 0 ? npmRoot.stdout.trim() : null;
+  const npmInstalled = npmGlobalRoot !== null && fs30.existsSync(path32.join(npmGlobalRoot, NPM_PACKAGE));
+  return {
+    containers,
+    images,
+    volumes,
+    networks,
+    worlds,
+    homeBytesNonWorld,
+    npmInstalled,
+    npmGlobalRoot
+  };
+}
+function listDocker(exec, args) {
+  const r = exec("docker", args);
+  if (r.exitCode !== 0) return [];
+  return r.stdout.split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function dirSize(p) {
+  let total = 0;
+  try {
+    const stack = [p];
+    while (stack.length > 0) {
+      const cur = stack.pop();
+      let entries;
+      try {
+        entries = fs30.readdirSync(cur, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const e of entries) {
+        const full = path32.join(cur, e.name);
+        try {
+          if (e.isDirectory()) stack.push(full);
+          else if (e.isFile()) total += fs30.statSync(full).size;
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return total;
+}
+function inspectWorldGitState(worldPath) {
+  const repoNotes = [];
+  let dirty = false;
+  try {
+    for (const entry of fs30.readdirSync(worldPath, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const repo = path32.join(worldPath, entry.name);
+      const gitDir = path32.join(repo, ".git");
+      if (!fs30.existsSync(gitDir)) continue;
+      try {
+        const status = execFileSync7("git", ["status", "--porcelain"], {
+          cwd: repo,
+          encoding: "utf-8",
+          stdio: ["ignore", "pipe", "ignore"]
+        }).trim();
+        if (status.length > 0) {
+          dirty = true;
+          repoNotes.push(`${entry.name}: uncommitted`);
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      try {
+        const ahead = execFileSync7(
+          "git",
+          ["rev-list", "--count", "@{upstream}..HEAD"],
+          { cwd: repo, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+        ).trim();
+        if (ahead && ahead !== "0") {
+          dirty = true;
+          repoNotes.push(`${entry.name}: ${ahead} unpushed`);
+        }
+      } catch {
+        dirty = true;
+        repoNotes.push(`${entry.name}: no-upstream`);
+      }
+    }
+  } catch {
+  }
+  return { dirty, note: repoNotes.join("; ") };
+}
+function renderSurvey(survey, opts) {
+  if (opts.json) {
+    return JSON.stringify(
+      {
+        containers: survey.containers,
+        images: survey.images,
+        volumes: survey.volumes,
+        networks: survey.networks,
+        worlds: survey.worlds.map((w) => ({
+          id: w.id,
+          bytes: w.bytes,
+          dirty: w.dirty,
+          note: w.note
+        })),
+        homeBytesNonWorld: survey.homeBytesNonWorld,
+        npmInstalled: survey.npmInstalled,
+        npmGlobalRoot: survey.npmGlobalRoot
+      },
+      null,
+      2
+    );
+  }
+  const lines = [];
+  const dirtyWorlds = survey.worlds.filter((w) => w.dirty);
+  const cleanWorlds = survey.worlds.filter((w) => !w.dirty);
+  const worldBytes = survey.worlds.reduce((acc, w) => acc + w.bytes, 0);
+  lines.push(pc14.bold(pc14.red("\u2014 olam implode survey \u2014")));
+  lines.push("");
+  lines.push(`  containers (olam-*):   ${survey.containers.length}`);
+  lines.push(`  images:                ${survey.images.length}`);
+  lines.push(`  volumes:               ${survey.volumes.length}`);
+  lines.push(`  networks:              ${survey.networks.length}`);
+  lines.push(
+    `  worlds:                ${survey.worlds.length}  (${dirtyWorlds.length} dirty, ${cleanWorlds.length} clean)`
+  );
+  lines.push(`  ~/.olam/* (non-world): ${formatBytes2(survey.homeBytesNonWorld)}`);
+  lines.push(`  worlds total:          ${formatBytes2(worldBytes)}`);
+  lines.push(
+    `  npm package installed: ${survey.npmInstalled ? `yes (at ${survey.npmGlobalRoot}/${NPM_PACKAGE})` : "no"}`
+  );
+  if (dirtyWorlds.length > 0) {
+    lines.push("");
+    lines.push(pc14.yellow(`  \u26A0 dirty worlds (${dirtyWorlds.length}) \u2014 pass --include-dirty to destroy:`));
+    for (const w of dirtyWorlds) {
+      lines.push(`    - ${w.id}  ${formatBytes2(w.bytes)}  (${w.note})`);
+    }
+  }
+  lines.push("");
+  lines.push(pc14.dim("  Run with --yes to actually destroy. Default is dry-run."));
+  return lines.join("\n");
+}
+function formatBytes2(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  if (n < 1024 * 1024 * 1024) return `${(n / 1024 / 1024).toFixed(1)} MB`;
+  return `${(n / 1024 / 1024 / 1024).toFixed(2)} GB`;
+}
+async function executeImplode(survey, opts) {
+  const exec = opts.exec ?? realExec;
+  const home = opts.olamHome ?? path32.join(os18.homedir(), ".olam");
+  const removed = [];
+  const skipped = [];
+  const errors = [];
+  if (!opts.keepWorlds) {
+    const sortedContainers = [...survey.containers].sort((a, b) => {
+      const aWorld = isWorldContainer(a);
+      const bWorld = isWorldContainer(b);
+      if (aWorld && !bWorld) return -1;
+      if (!aWorld && bWorld) return 1;
+      return 0;
+    });
+    for (const name of sortedContainers) {
+      const r = exec("docker", ["rm", "-f", name]);
+      if (r.exitCode === 0) removed.push(`container:${name}`);
+      else errors.push(`container:${name}: ${r.stderr.trim()}`);
+    }
+  } else {
+    for (const c of survey.containers) skipped.push(`container:${c}`);
+  }
+  if (!opts.keepImages) {
+    for (const ref of survey.images) {
+      const r = exec("docker", ["rmi", "-f", ref]);
+      if (r.exitCode === 0) removed.push(`image:${ref}`);
+      else errors.push(`image:${ref}: ${r.stderr.trim()}`);
+    }
+  } else {
+    for (const i of survey.images) skipped.push(`image:${i}`);
+  }
+  if (!opts.keepVolumes && !opts.keepVault) {
+    for (const v of survey.volumes) {
+      const r = exec("docker", ["volume", "rm", "-f", v]);
+      if (r.exitCode === 0) removed.push(`volume:${v}`);
+      else errors.push(`volume:${v}: ${r.stderr.trim()}`);
+    }
+  } else if (opts.keepVault) {
+    for (const v of survey.volumes) {
+      if (v === "olam-auth-data" || v === "olam-mcp-auth-data") {
+        skipped.push(`volume:${v} (--keep-vault)`);
+        continue;
+      }
+      const r = exec("docker", ["volume", "rm", "-f", v]);
+      if (r.exitCode === 0) removed.push(`volume:${v}`);
+      else errors.push(`volume:${v}: ${r.stderr.trim()}`);
+    }
+  } else {
+    for (const v of survey.volumes) skipped.push(`volume:${v}`);
+  }
+  if (!opts.keepNetworks) {
+    for (const n of survey.networks) {
+      const r = exec("docker", ["network", "rm", n]);
+      if (r.exitCode === 0) removed.push(`network:${n}`);
+      else errors.push(`network:${n}: ${r.stderr.trim()}`);
+    }
+  } else {
+    for (const n of survey.networks) skipped.push(`network:${n}`);
+  }
+  if (fs30.existsSync(home)) {
+    if (opts.keepVault) {
+      for (const entry of fs30.readdirSync(home, { withFileTypes: true })) {
+        if (entry.name === "auth-data") {
+          skipped.push(`fs:~/.olam/auth-data (--keep-vault)`);
+          continue;
+        }
+        const target = path32.join(home, entry.name);
+        try {
+          fs30.rmSync(target, { recursive: true, force: true });
+          removed.push(`fs:${target}`);
+        } catch (err) {
+          errors.push(`fs:${target}: ${err.message}`);
+        }
+      }
+    } else {
+      try {
+        fs30.rmSync(home, { recursive: true, force: true });
+        removed.push(`fs:${home}`);
+      } catch (err) {
+        errors.push(`fs:${home}: ${err.message}`);
+      }
+    }
+  }
+  if (!opts.keepNpm && survey.npmInstalled) {
+    const r = exec("npm", ["uninstall", "-g", NPM_PACKAGE]);
+    if (r.exitCode === 0) removed.push(`npm:${NPM_PACKAGE}`);
+    else errors.push(`npm:${NPM_PACKAGE}: ${r.stderr.trim()}`);
+  } else if (opts.keepNpm) {
+    skipped.push(`npm:${NPM_PACKAGE}`);
+  }
+  return { removed, skipped, errors };
+}
+function isWorldContainer(name) {
+  const stack = /* @__PURE__ */ new Set(["olam-host-cp", "olam-auth", "olam-mcp-auth", "olam-docker-socket-proxy"]);
+  return !stack.has(name);
+}
+async function readConfirmation() {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  const answer = await rl.question('Type "implode" to proceed: ');
+  rl.close();
+  return answer.trim();
+}
+function registerImplode(program2) {
+  program2.command("implode").description(
+    "Destroy ALL local olam install + configs (containers, images, volumes, ~/.olam/, npm package). Default is dry-run."
+  ).option("-y, --yes", "Actually destroy (default is dry-run)", false).option(
+    "--include-dirty",
+    "Also destroy worlds with uncommitted/unpushed work",
+    false
+  ).option("--keep-worlds", "Skip world container destruction", false).option("--keep-images", "Skip docker image removal", false).option("--keep-vault", "Preserve auth-service credentials (~/.olam/auth-data + olam-*-data volumes)", false).option("--keep-npm", "Skip global npm package uninstall", false).option("--keep-volumes", "Skip docker volume removal", false).option("--keep-networks", "Skip docker network removal", false).option("--json", "Emit machine-readable JSON survey", false).action(async (raw) => {
+    const opts = {
+      yes: raw.yes === true,
+      includeDirty: raw.includeDirty === true,
+      keepWorlds: raw.keepWorlds === true,
+      keepImages: raw.keepImages === true,
+      keepVault: raw.keepVault === true,
+      keepNpm: raw.keepNpm === true,
+      keepVolumes: raw.keepVolumes === true,
+      keepNetworks: raw.keepNetworks === true,
+      json: raw.json === true
+    };
+    const exitCode = await runImplode(opts);
+    process.exitCode = exitCode;
+  });
+}
+async function runImplode(opts) {
+  const survey = surveyOlam({ exec: opts.exec, olamHome: opts.olamHome });
+  if (opts.json && !opts.yes) {
+    process.stdout.write(renderSurvey(survey, opts) + "\n");
+    return 0;
+  }
+  if (!opts.yes) {
+    process.stdout.write(renderSurvey(survey, opts) + "\n");
+    return 0;
+  }
+  const dirty = survey.worlds.filter((w) => w.dirty);
+  if (dirty.length > 0 && !opts.includeDirty && !opts.keepWorlds) {
+    printError(
+      `Refusing to destroy ${dirty.length} world(s) with uncommitted/unpushed work. Pass --include-dirty to override or --keep-worlds to skip world destruction.`
+    );
+    for (const w of dirty) {
+      process.stderr.write(`  - ${w.id} (${w.note})
+`);
+    }
+    return 2;
+  }
+  process.stdout.write(renderSurvey(survey, opts) + "\n");
+  printWarning("This will permanently destroy the resources listed above.");
+  printInfo("Project files", "~/Projects/* and ~/.claude/ are NOT touched.");
+  const answer = opts.confirmAnswer ?? await readConfirmation();
+  if (answer !== "implode") {
+    printError(`Confirmation failed (got "${answer}", expected "implode"). Aborting.`);
+    return 3;
+  }
+  printHeader("Imploding olam");
+  const result = await executeImplode(survey, opts);
+  for (const r of result.removed) printSuccess(`removed ${r}`);
+  for (const s of result.skipped) printInfo("skipped", s);
+  for (const e of result.errors) printError(e);
+  printHeader("Implode complete");
+  printInfo("Removed", String(result.removed.length));
+  printInfo("Skipped", String(result.skipped.length));
+  printInfo("Errors", String(result.errors.length));
+  process.stdout.write("\n");
+  process.stdout.write(`To reinstall a fresh copy:
+`);
+  process.stdout.write(`  ${pc14.cyan(`npm install -g ${NPM_PACKAGE}`)}
+`);
+  process.stdout.write(`  ${pc14.cyan("olam init")}
+`);
+  process.stdout.write(`  ${pc14.cyan("olam auth login")}
+`);
+  return result.errors.length > 0 ? 1 : 0;
+}
+
 // src/commands/enter.ts
 init_context();
 init_output();
 import { execSync as execSync8 } from "node:child_process";
-import pc14 from "picocolors";
+import pc15 from "picocolors";
 var SAFE_IDENT3 = /^[a-z0-9][a-z0-9-]{0,63}$/;
 function buildStartClaudeCommands(containerName, sessionName, task) {
   if (!SAFE_IDENT3.test(containerName)) {
@@ -17260,7 +17630,7 @@ function registerEnter(program2) {
       }
       console.log("Run these commands in order to enter the world:\n");
       for (const step of steps) {
-        console.log(`  ${pc14.dim(`# ${step.description}`)}`);
+        console.log(`  ${pc15.dim(`# ${step.description}`)}`);
         if (step.stdin !== void 0) {
           const escaped = step.stdin.replace(/'/g, "'\\''");
           console.log(`  printf '%s' '${escaped}' | ${step.command}`);
@@ -17294,11 +17664,11 @@ function registerEnter(program2) {
       return;
     }
     console.log("Run this command to enter the world:\n");
-    console.log(`  ${pc14.bold(result.command)}`);
+    console.log(`  ${pc15.bold(result.command)}`);
     const containerName = `olam-${worldId}-devbox`;
     console.log(
       `
-${pc14.dim(`Observe dispatch: docker exec -it ${containerName} tmux attach -t olam-dispatch -r`)}`
+${pc15.dim(`Observe dispatch: docker exec -it ${containerName} tmux attach -t olam-dispatch -r`)}`
     );
   });
 }
@@ -17308,7 +17678,7 @@ init_context();
 init_output();
 init_exit_codes();
 init_world_paths();
-import * as fs30 from "node:fs";
+import * as fs31 from "node:fs";
 import "node:path";
 import ora6 from "ora";
 function registerCrystallize(program2, options = {}) {
@@ -17340,7 +17710,7 @@ function registerCrystallize(program2, options = {}) {
       return;
     }
     const thoughtDbPath = getWorldDbPath(world.workspacePath);
-    if (!fs30.existsSync(thoughtDbPath)) {
+    if (!fs31.existsSync(thoughtDbPath)) {
       printError(`No thoughts captured yet for "${worldId}". Run a dispatch first.`);
       process.exitCode = EXIT_GENERIC_ERROR;
       return;
@@ -17410,7 +17780,7 @@ function registerCrystallize(program2, options = {}) {
 
 // src/commands/pr.ts
 init_registry();
-import pc15 from "picocolors";
+import pc16 from "picocolors";
 
 // ../core/dist/pr-gate/client.js
 var HOST_CONTROL_PLANE_BASE2 = 19080;
@@ -17491,26 +17861,26 @@ async function findGate(id) {
   return null;
 }
 function formatStateBadge(state) {
-  if (state === "approve") return pc15.green("approve");
-  if (state === "block") return pc15.red("block");
-  if (state === "denied") return pc15.gray("denied");
-  return pc15.yellow("pending");
+  if (state === "approve") return pc16.green("approve");
+  if (state === "block") return pc16.red("block");
+  if (state === "denied") return pc16.gray("denied");
+  return pc16.yellow("pending");
 }
 function registerPr(program2) {
   const pr = program2.command("pr").description("Review and decide PR-gate requests from running worlds");
   pr.command("list").description("List all PR-gate requests across every running world").action(async () => {
     const all = await fanoutList();
     if (all.length === 0) {
-      console.log(pc15.dim("No gates open."));
+      console.log(pc16.dim("No gates open."));
       return;
     }
     printHeader(`${all.length} gate(s)`);
     for (const { world, gate } of all) {
       const badge = formatStateBadge(gate.state);
       console.log(
-        `  ${pc15.bold(gate.id.slice(0, 8))} ${badge.padEnd(20)} ${pc15.dim(world.name)} ${pc15.dim(gate.branch)}`
+        `  ${pc16.bold(gate.id.slice(0, 8))} ${badge.padEnd(20)} ${pc16.dim(world.name)} ${pc16.dim(gate.branch)}`
       );
-      console.log(`    ${pc15.dim(gate.command.slice(0, 100))}`);
+      console.log(`    ${pc16.dim(gate.command.slice(0, 100))}`);
     }
   });
   pr.command("show").description("Show full gate detail (diff, command, commits)").argument("<id>", "Gate id (prefix match ok)").action(async (id) => {
@@ -17533,9 +17903,9 @@ function registerPr(program2) {
       if (gate.reason) printInfo("Reason", gate.reason);
     }
     printHeader("Commits");
-    console.log(gate.commitLog || pc15.dim("  (empty)"));
+    console.log(gate.commitLog || pc16.dim("  (empty)"));
     printHeader("Diff stat");
-    console.log(gate.diffStat || pc15.dim("  (empty)"));
+    console.log(gate.diffStat || pc16.dim("  (empty)"));
   });
   function decideCommand(verb, decision) {
     pr.command(verb).description(`${verb[0].toUpperCase()}${verb.slice(1)} a pending gate`).argument("<id>", "Gate id").option("--reason <reason>", "Short free-text reason").option("--by <name>", "Deciding identity (defaults to $USER)", process.env["USER"] ?? "human").action(async (id, opts) => {
@@ -17660,7 +18030,7 @@ function registerLanes(program2) {
 // src/commands/policy-check.ts
 init_loader2();
 import { execSync as execSync9 } from "node:child_process";
-import pc16 from "picocolors";
+import pc17 from "picocolors";
 
 // ../../node_modules/balanced-match/dist/esm/index.js
 var balanced = (a, b, str) => {
@@ -18714,11 +19084,11 @@ var qmarksTestNoExtDot = ([$0]) => {
   return (f) => f.length === len && f !== "." && f !== "..";
 };
 var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-var path33 = {
+var path34 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep = defaultPlatform === "win32" ? path33.win32.sep : path33.posix.sep;
+var sep = defaultPlatform === "win32" ? path34.win32.sep : path34.posix.sep;
 minimatch.sep = sep;
 var GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
@@ -19520,7 +19890,7 @@ function registerPolicyCheck(program2) {
     const workspaceRoot = opts.workspace ?? process.cwd();
     const policies = loadPolicies(workspaceRoot);
     if (policies.length === 0) {
-      console.log(pc16.dim("policy-check: no policies found in .olam/policies/ \u2014 nothing to enforce"));
+      console.log(pc17.dim("policy-check: no policies found in .olam/policies/ \u2014 nothing to enforce"));
       return;
     }
     const diff = getDiff(opts.base, workspaceRoot);
@@ -19529,11 +19899,11 @@ function registerPolicyCheck(program2) {
     for (const result of results) {
       if (result.passed) continue;
       if (result.severity === "error") {
-        console.error(`${pc16.red("policy error")} [${result.policyId}]`);
+        console.error(`${pc17.red("policy error")} [${result.policyId}]`);
         console.error(result.message);
         hasErrorFailure = true;
       } else {
-        console.warn(`${pc16.yellow("policy warn")} [${result.policyId}]`);
+        console.warn(`${pc17.yellow("policy warn")} [${result.policyId}]`);
         console.warn(result.message);
       }
     }
@@ -19544,7 +19914,7 @@ function registerPolicyCheck(program2) {
 }
 
 // src/commands/worldspec/compile.ts
-import { existsSync as existsSync31, mkdirSync as mkdirSync18, readFileSync as readFileSync21, writeFileSync as writeFileSync14 } from "node:fs";
+import { existsSync as existsSync32, mkdirSync as mkdirSync18, readFileSync as readFileSync21, writeFileSync as writeFileSync14 } from "node:fs";
 import { resolve as resolvePath } from "node:path";
 import YAML5 from "yaml";
 
@@ -19827,11 +20197,11 @@ function zodIssueToError(issue, doc, lineCounter) {
     suggestion: deriveSuggestion(issue)
   };
 }
-function formatJsonPath(path48) {
-  if (path48.length === 0)
+function formatJsonPath(path49) {
+  if (path49.length === 0)
     return "<root>";
   let out = "";
-  for (const seg of path48) {
+  for (const seg of path49) {
     if (typeof seg === "number") {
       out += `[${seg}]`;
     } else {
@@ -19840,11 +20210,11 @@ function formatJsonPath(path48) {
   }
   return out;
 }
-function resolveYamlLocation(path48, doc, lineCounter) {
+function resolveYamlLocation(path49, doc, lineCounter) {
   let bestLine = 0;
   let bestColumn = 0;
-  for (let depth = path48.length; depth >= 0; depth -= 1) {
-    const segment = path48.slice(0, depth);
+  for (let depth = path49.length; depth >= 0; depth -= 1) {
+    const segment = path49.slice(0, depth);
     try {
       const node = doc.getIn(segment, true);
       if (node && typeof node === "object" && "range" in node) {
@@ -20062,11 +20432,11 @@ function topoSort(nodes) {
 }
 function traceCycle(start, byId) {
   const seen = /* @__PURE__ */ new Set();
-  const path48 = [];
+  const path49 = [];
   let current = start;
   while (current && !seen.has(current)) {
     seen.add(current);
-    path48.push(current);
+    path49.push(current);
     const node = byId.get(current);
     const next = node?.dependsOn[0];
     if (next === void 0)
@@ -20074,10 +20444,10 @@ function traceCycle(start, byId) {
     current = next;
   }
   if (current && seen.has(current)) {
-    const idx = path48.indexOf(current);
-    return [...path48.slice(idx), current];
+    const idx = path49.indexOf(current);
+    return [...path49.slice(idx), current];
   }
-  return path48;
+  return path49;
 }
 
 // ../core/dist/executor/types.js
@@ -20301,11 +20671,11 @@ async function resolveDigests(lockfile, resolver) {
 }
 
 // ../core/dist/worldspec/image-digest.js
-import { execFileSync as execFileSync7 } from "node:child_process";
+import { execFileSync as execFileSync8 } from "node:child_process";
 var DOCKER_SUBPROCESS_TIMEOUT_MS = 3e4;
 var dockerDigestResolver = async (image, source) => {
   if (source === "local") {
-    const out = execFileSync7("docker", ["inspect", image, "--format", "{{.Id}}"], {
+    const out = execFileSync8("docker", ["inspect", image, "--format", "{{.Id}}"], {
       encoding: "utf8",
       stdio: ["ignore", "pipe", "pipe"],
       timeout: DOCKER_SUBPROCESS_TIMEOUT_MS,
@@ -20316,7 +20686,7 @@ var dockerDigestResolver = async (image, source) => {
     }
     return out;
   }
-  const raw = execFileSync7("docker", ["buildx", "imagetools", "inspect", image], {
+  const raw = execFileSync8("docker", ["buildx", "imagetools", "inspect", image], {
     encoding: "utf8",
     stdio: ["ignore", "pipe", "pipe"],
     timeout: DOCKER_SUBPROCESS_TIMEOUT_MS,
@@ -20347,7 +20717,7 @@ function registerWorldspecCompile(parent) {
     const sourcePolicies = [];
     for (const p of paths) {
       const abs = resolvePath(process.cwd(), p);
-      if (!existsSync31(abs)) {
+      if (!existsSync32(abs)) {
         printError(`worldspec not found at ${abs}`);
         process.exit(EXIT_WORLDSPEC_FILE_NOT_FOUND);
       }
@@ -20438,7 +20808,7 @@ function getPkgVersion() {
 // src/commands/worldspec/init.ts
 init_exit_codes();
 init_output();
-import { existsSync as existsSync32, mkdirSync as mkdirSync19, readFileSync as readFileSync22, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync33, mkdirSync as mkdirSync19, readFileSync as readFileSync22, writeFileSync as writeFileSync15 } from "node:fs";
 import { execSync as execSync10 } from "node:child_process";
 import { basename as basename3, resolve as resolvePath2 } from "node:path";
 function registerWorldspecInit(parent) {
@@ -20456,7 +20826,7 @@ function registerWorldspecInit(parent) {
     const cwd = process.cwd();
     const targetDir = resolvePath2(cwd, ".olam/worldspecs");
     const targetFile = resolvePath2(targetDir, "default.yaml");
-    if (existsSync32(targetFile) && !opts.force) {
+    if (existsSync33(targetFile) && !opts.force) {
       printError(
         `${targetFile} already exists; pass --force to overwrite`
       );
@@ -20490,12 +20860,12 @@ function registerWorldspecInit(parent) {
   });
 }
 function detectProjectShape(root, useAdbYaml) {
-  const hasGemfile = existsSync32(resolvePath2(root, "Gemfile"));
-  const hasNodePackageJson = existsSync32(resolvePath2(root, "package.json"));
-  const hasAdbYaml = existsSync32(resolvePath2(root, ".adb.yaml"));
+  const hasGemfile = existsSync33(resolvePath2(root, "Gemfile"));
+  const hasNodePackageJson = existsSync33(resolvePath2(root, "package.json"));
+  const hasAdbYaml = existsSync33(resolvePath2(root, ".adb.yaml"));
   let rubyVersion = null;
   const rubyVersionPath = resolvePath2(root, ".ruby-version");
-  if (existsSync32(rubyVersionPath)) {
+  if (existsSync33(rubyVersionPath)) {
     try {
       const raw = readFileSync22(rubyVersionPath, "utf8").trim();
       const match2 = raw.match(/(\d+\.\d+\.\d+)/);
@@ -21900,7 +22270,7 @@ function registerWorldspecSchema(parent) {
 }
 
 // src/commands/worldspec/validate.ts
-import { existsSync as existsSync33, readFileSync as readFileSync23 } from "node:fs";
+import { existsSync as existsSync34, readFileSync as readFileSync23 } from "node:fs";
 import { resolve as resolvePath4 } from "node:path";
 init_exit_codes();
 init_output();
@@ -21917,7 +22287,7 @@ function registerWorldspecValidate(parent) {
     "human"
   ).action(async (pathArg, opts) => {
     const absPath = resolvePath4(process.cwd(), pathArg);
-    if (!existsSync33(absPath)) {
+    if (!existsSync34(absPath)) {
       printError(`worldspec not found at ${absPath}`);
       process.exit(EXIT_WORLDSPEC_FILE_NOT_FOUND);
     }
@@ -21969,23 +22339,23 @@ function registerWorldspec(program2) {
 // src/commands/upgrade.ts
 init_output();
 init_host_cp();
-import * as fs33 from "node:fs";
-import * as path36 from "node:path";
+import * as fs34 from "node:fs";
+import * as path37 from "node:path";
 import { spawnSync as spawnSync11 } from "node:child_process";
 import ora7 from "ora";
-import pc17 from "picocolors";
+import pc18 from "picocolors";
 
 // src/commands/upgrade-lock.ts
-import * as fs31 from "node:fs";
-import * as os18 from "node:os";
-import * as path34 from "node:path";
+import * as fs32 from "node:fs";
+import * as os19 from "node:os";
+import * as path35 from "node:path";
 import { spawnSync as spawnSync10 } from "node:child_process";
-var LOCK_FILE_PATH = path34.join(os18.homedir(), ".olam", ".upgrade.lock");
+var LOCK_FILE_PATH = path35.join(os19.homedir(), ".olam", ".upgrade.lock");
 var STALE_LOCK_TIMEOUT_MS = 5 * 60 * 1e3;
 function readLockFile(lockPath) {
   try {
-    if (!fs31.existsSync(lockPath)) return null;
-    const raw = fs31.readFileSync(lockPath, "utf-8").trim();
+    if (!fs32.existsSync(lockPath)) return null;
+    const raw = fs32.readFileSync(lockPath, "utf-8").trim();
     if (raw.length === 0) return null;
     const parsed = JSON.parse(raw);
     if (typeof parsed.pid !== "number" || typeof parsed.startTs !== "number") return null;
@@ -22030,16 +22400,16 @@ function isStaleLock(content, nowMs = Date.now()) {
   return false;
 }
 function acquireLock(lockPath = LOCK_FILE_PATH, nowMs = Date.now()) {
-  const dir = path34.dirname(lockPath);
-  fs31.mkdirSync(dir, { recursive: true });
+  const dir = path35.dirname(lockPath);
+  fs32.mkdirSync(dir, { recursive: true });
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      const fd = fs31.openSync(lockPath, "wx", 420);
+      const fd = fs32.openSync(lockPath, "wx", 420);
       try {
         const content = { pid: process.pid, startTs: nowMs };
-        fs31.writeSync(fd, JSON.stringify(content));
+        fs32.writeSync(fd, JSON.stringify(content));
       } finally {
-        fs31.closeSync(fd);
+        fs32.closeSync(fd);
       }
       return { acquired: true, lockPath };
     } catch (err) {
@@ -22048,7 +22418,7 @@ function acquireLock(lockPath = LOCK_FILE_PATH, nowMs = Date.now()) {
       const existing2 = readLockFile(lockPath);
       if (isStaleLock(existing2, nowMs)) {
         try {
-          fs31.unlinkSync(lockPath);
+          fs32.unlinkSync(lockPath);
         } catch (unlinkErr) {
           const ucode = unlinkErr.code;
           if (ucode !== "ENOENT") throw unlinkErr;
@@ -22073,7 +22443,7 @@ function acquireLock(lockPath = LOCK_FILE_PATH, nowMs = Date.now()) {
 }
 function releaseLock(lockPath = LOCK_FILE_PATH) {
   try {
-    fs31.unlinkSync(lockPath);
+    fs32.unlinkSync(lockPath);
   } catch (err) {
     const code = err.code;
     if (code !== "ENOENT") throw err;
@@ -22091,19 +22461,19 @@ function formatRefusalMessage(result, lockPath = LOCK_FILE_PATH) {
 }
 
 // src/commands/upgrade-log.ts
-import * as fs32 from "node:fs";
-import * as os19 from "node:os";
-import * as path35 from "node:path";
+import * as fs33 from "node:fs";
+import * as os20 from "node:os";
+import * as path36 from "node:path";
 function getUpgradeLogPath() {
-  const home = process.env["HOME"] ?? os19.homedir();
-  return path35.join(home, ".olam", "upgrade.log");
+  const home = process.env["HOME"] ?? os20.homedir();
+  return path36.join(home, ".olam", "upgrade.log");
 }
 var UPGRADE_LOG_PATH = getUpgradeLogPath();
 function appendUpgradeLog(row, logPath = getUpgradeLogPath()) {
   try {
-    fs32.mkdirSync(path35.dirname(logPath), { recursive: true });
+    fs33.mkdirSync(path36.dirname(logPath), { recursive: true });
     const line = JSON.stringify(row) + "\n";
-    fs32.appendFileSync(logPath, line, { mode: 420 });
+    fs33.appendFileSync(logPath, line, { mode: 420 });
   } catch (err) {
     process.stderr.write(
       `[upgrade-log] failed to append: ${err instanceof Error ? err.message : String(err)}
@@ -22112,10 +22482,10 @@ function appendUpgradeLog(row, logPath = getUpgradeLogPath()) {
   }
 }
 function readUpgradeLog(limit = 10, logPath = getUpgradeLogPath()) {
-  if (!fs32.existsSync(logPath)) return [];
+  if (!fs33.existsSync(logPath)) return [];
   let raw;
   try {
-    raw = fs32.readFileSync(logPath, "utf-8");
+    raw = fs33.readFileSync(logPath, "utf-8");
   } catch (err) {
     process.stderr.write(
       `[upgrade-log] failed to read: ${err instanceof Error ? err.message : String(err)}
@@ -22208,12 +22578,12 @@ init_protocol_version();
 init_install_root();
 var AUTH_HEALTH_URL2 = "http://127.0.0.1:9999/health";
 function isNodeModulesInSync(cwd) {
-  const lockPath = path36.join(cwd, "package-lock.json");
-  const markerPath = path36.join(cwd, "node_modules", ".package-lock.json");
-  if (!fs33.existsSync(lockPath) || !fs33.existsSync(markerPath)) return false;
+  const lockPath = path37.join(cwd, "package-lock.json");
+  const markerPath = path37.join(cwd, "node_modules", ".package-lock.json");
+  if (!fs34.existsSync(lockPath) || !fs34.existsSync(markerPath)) return false;
   try {
-    const lockStat = fs33.statSync(lockPath);
-    const markerStat = fs33.statSync(markerPath);
+    const lockStat = fs34.statSync(lockPath);
+    const markerStat = fs34.statSync(markerPath);
     return markerStat.mtimeMs >= lockStat.mtimeMs;
   } catch {
     return false;
@@ -22229,8 +22599,8 @@ function shouldSkipInstall(opts, cwd) {
   return { skip: false };
 }
 function validateRepoRoot(cwd) {
-  const marker = path36.join(cwd, "packages/host-cp/compose.yaml");
-  if (!fs33.existsSync(marker)) {
+  const marker = path37.join(cwd, "packages/host-cp/compose.yaml");
+  if (!fs34.existsSync(marker)) {
     return {
       ok: false,
       error: `Not an olam repo root (expected ${marker}).
@@ -22262,7 +22632,7 @@ function extractBundleHash(indexHtml) {
 }
 function runStep2(label, cmd, args, opts = {}) {
   const start = Date.now();
-  process.stdout.write(`  ${pc17.dim(label.padEnd(34))}`);
+  process.stdout.write(`  ${pc18.dim(label.padEnd(34))}`);
   const result = spawnSync11(cmd, [...args], {
     encoding: "utf-8",
     stdio: ["ignore", "pipe", "pipe"],
@@ -22272,7 +22642,7 @@ function runStep2(label, cmd, args, opts = {}) {
   const durationMs = Date.now() - start;
   const ok = result.status === 0 && result.error === void 0;
   const dur = `${(durationMs / 1e3).toFixed(1)}s`;
-  process.stdout.write(`${ok ? pc17.green("\u2713") : pc17.red("\u2717")} ${dur}
+  process.stdout.write(`${ok ? pc18.green("\u2713") : pc18.red("\u2717")} ${dur}
 `);
   return {
     ok,
@@ -22484,8 +22854,8 @@ function performRollbackSwap(plan) {
 }
 async function confirm2(message) {
   if (!process.stdin.isTTY) return true;
-  const { createInterface: createInterface4 } = await import("node:readline");
-  const rl = createInterface4({ input: process.stdin, output: process.stdout });
+  const { createInterface: createInterface5 } = await import("node:readline");
+  const rl = createInterface5({ input: process.stdin, output: process.stdout });
   return new Promise((resolve10) => {
     rl.question(`${message} [y/N] `, (answer) => {
       rl.close();
@@ -22586,9 +22956,9 @@ async function recreateAuthService() {
   }
 }
 function readBundleHash(cwd) {
-  const indexPath = path36.join(cwd, "packages/control-plane/public/index.html");
-  if (!fs33.existsSync(indexPath)) return null;
-  return extractBundleHash(fs33.readFileSync(indexPath, "utf-8"));
+  const indexPath = path37.join(cwd, "packages/control-plane/public/index.html");
+  if (!fs34.existsSync(indexPath)) return null;
+  return extractBundleHash(fs34.readFileSync(indexPath, "utf-8"));
 }
 async function runUpgradePullByDigest(deps = {}) {
   const docker2 = deps.docker ?? realDocker;
@@ -22600,7 +22970,7 @@ async function runUpgradePullByDigest(deps = {}) {
   if (info.exitCode !== 0) {
     infoSpinner.fail("docker daemon not reachable");
     process.stderr.write(
-      `${pc17.red("error")} docker info exited with ${info.exitCode}.
+      `${pc18.red("error")} docker info exited with ${info.exitCode}.
   Ensure Docker Desktop / Colima / Rancher is running, then retry.
 `
     );
@@ -22635,7 +23005,7 @@ async function runUpgradePullByDigest(deps = {}) {
     pullSpinner.fail(`Pull failed for ${failed.map((r) => r.name).join(", ")}`);
     for (const f of failed) {
       process.stderr.write(
-        `  ${pc17.red(f.name)} (${f.ref}):
+        `  ${pc18.red(f.name)} (${f.ref}):
     exit=${f.result.exitCode}
     stderr: ${f.result.stderr.split("\n")[0] ?? "(empty)"}
 `
@@ -22656,7 +23026,7 @@ async function runUpgradePullByDigest(deps = {}) {
     if (inspect.exitCode !== 0) {
       handshakeSpinner.fail(`Could not inspect ${name}`);
       process.stderr.write(
-        `${pc17.red("error")} docker inspect ${ref} failed: ${inspect.stderr}
+        `${pc18.red("error")} docker inspect ${ref} failed: ${inspect.stderr}
 `
       );
       return { exitCode: EXIT_GENERIC_ERROR, summary: `inspect failed: ${name}` };
@@ -22668,7 +23038,7 @@ async function runUpgradePullByDigest(deps = {}) {
     const decision = checkProtocolOverlap(versions);
     if (!decision.compatible) {
       handshakeSpinner.fail(`Protocol mismatch on ${name}`);
-      process.stderr.write(`${pc17.red("error")} ${decision.remedy}
+      process.stderr.write(`${pc18.red("error")} ${decision.remedy}
 `);
       return {
         exitCode: EXIT_PROTOCOL_MISMATCH,
@@ -22698,7 +23068,7 @@ async function runUpgradePullByDigest(deps = {}) {
     const r = tagger(t.from, t.to);
     if (!r.ok) {
       tagSpinner.fail(`docker tag failed for ${t.name}`);
-      process.stderr.write(`${pc17.red("error")} ${r.error ?? "docker tag failed"}
+      process.stderr.write(`${pc18.red("error")} ${r.error ?? "docker tag failed"}
 `);
       return { exitCode: EXIT_GENERIC_ERROR, summary: `tag failed: ${t.name}` };
     }
@@ -22716,7 +23086,7 @@ async function runUpgradePullByDigest(deps = {}) {
   if (!composeResult.ok) {
     composeSpinner.fail("compose recreate failed");
     process.stderr.write(
-      `${pc17.red("error")} docker compose up --force-recreate host-cp failed:
+      `${pc18.red("error")} docker compose up --force-recreate host-cp failed:
   ${composeResult.stderr.split("\n").slice(0, 3).join("\n  ")}
 `
     );
@@ -22729,7 +23099,7 @@ async function runUpgradePullByDigest(deps = {}) {
   if (!authResult.ok) {
     authSpinner.fail("auth-service recreate failed");
     process.stderr.write(
-      `${pc17.red("error")} ${authResult.error ?? "unknown failure"}
+      `${pc18.red("error")} ${authResult.error ?? "unknown failure"}
 `
     );
     return { exitCode: EXIT_GENERIC_ERROR, summary: "auth recreate failed" };
@@ -22742,7 +23112,7 @@ async function runUpgradePullByDigest(deps = {}) {
     if (!mcpResult.ok) {
       mcpSpinner.fail("mcp-auth-service recreate failed");
       process.stderr.write(
-        `${pc17.red("error")} ${mcpResult.error ?? "unknown failure"}
+        `${pc18.red("error")} ${mcpResult.error ?? "unknown failure"}
 `
       );
       return { exitCode: EXIT_GENERIC_ERROR, summary: "mcp-auth recreate failed" };
@@ -22935,11 +23305,11 @@ manually inspect images with \`docker images olam-*:olam-rollback\`.`
   process.once("SIGINT", releaseOnSignal);
   process.once("SIGTERM", releaseOnSignal);
   try {
-    process.stdout.write(`  ${pc17.dim("rollback retag (3 ops)".padEnd(34))}`);
+    process.stdout.write(`  ${pc18.dim("rollback retag (3 ops)".padEnd(34))}`);
     const swapStart = Date.now();
     const swapResult = performRollbackSwap(PRODUCTION_SWAP_PLAN);
     const swapDur = `${((Date.now() - swapStart) / 1e3).toFixed(1)}s`;
-    process.stdout.write(`${swapResult.ok ? pc17.green("\u2713") : pc17.red("\u2717")} ${swapDur}
+    process.stdout.write(`${swapResult.ok ? pc18.green("\u2713") : pc18.red("\u2717")} ${swapDur}
 `);
     if (!swapResult.ok) {
       printError(`Rollback retag failed: ${swapResult.summary}`);
@@ -22949,11 +23319,11 @@ manually inspect images with \`docker images olam-*:olam-rollback\`.`
     printInfo("Rollback", swapResult.summary);
     const composeFile = findComposeFile();
     const authSecret = readAuthSecret2();
-    process.stdout.write(`  ${pc17.dim("docker compose recreate host-cp".padEnd(34))}`);
+    process.stdout.write(`  ${pc18.dim("docker compose recreate host-cp".padEnd(34))}`);
     const composeStart = Date.now();
     const composeResult = runCompose(["up", "-d", "--force-recreate", "--no-deps", "host-cp"], composeFile, buildComposeEnv(authSecret, captureGhToken()));
     const composeDur = `${((Date.now() - composeStart) / 1e3).toFixed(1)}s`;
-    process.stdout.write(`${composeResult.ok ? pc17.green("\u2713") : pc17.red("\u2717")} ${composeDur}
+    process.stdout.write(`${composeResult.ok ? pc18.green("\u2713") : pc18.red("\u2717")} ${composeDur}
 `);
     if (!composeResult.ok) {
       printError(
@@ -22964,10 +23334,10 @@ Canonical tags are at :olam-rollback (good); container restart pending. Manually
       process.exitCode = 1;
       return;
     }
-    process.stdout.write(`  ${pc17.dim("recreate auth-service".padEnd(34))}`);
+    process.stdout.write(`  ${pc18.dim("recreate auth-service".padEnd(34))}`);
     const authResult = await recreateAuthService();
     const authDur = `${(authResult.durationMs / 1e3).toFixed(1)}s`;
-    process.stdout.write(`${authResult.ok ? pc17.green("\u2713") : pc17.red("\u2717")} ${authDur}
+    process.stdout.write(`${authResult.ok ? pc18.green("\u2713") : pc18.red("\u2717")} ${authDur}
 `);
     if (!authResult.ok) {
       printError(`Auth-service recreate failed: ${authResult.error ?? "unknown"}`);
@@ -23088,7 +23458,7 @@ ${buildResult.stderr}`);
     return;
   }
   const authSecret = readAuthSecret2();
-  const spaDir = path36.join(cwd, "packages/control-plane/app");
+  const spaDir = path37.join(cwd, "packages/control-plane/app");
   const spaResult = runStep2(
     "vite build (SPA)",
     "npx",
@@ -23133,7 +23503,7 @@ ${spaResult.stderr}`);
       throw err;
     }
     if (step.tee) {
-      process.stdout.write(`  ${pc17.dim(step.label.padEnd(34))}
+      process.stdout.write(`  ${pc18.dim(step.label.padEnd(34))}
 `);
       const start = Date.now();
       const result = spawnSync11("bash", [scriptPath], {
@@ -23144,7 +23514,7 @@ ${spaResult.stderr}`);
       const durationMs = Date.now() - start;
       const ok = result.status === 0 && result.error === void 0;
       const dur = `${(durationMs / 1e3).toFixed(1)}s`;
-      process.stdout.write(`  ${pc17.dim(step.label.padEnd(34))}${ok ? pc17.green("\u2713") : pc17.red("\u2717")} ${dur}
+      process.stdout.write(`  ${pc18.dim(step.label.padEnd(34))}${ok ? pc18.green("\u2713") : pc18.red("\u2717")} ${dur}
 `);
       timings.push({ label: step.label, durationMs });
       if (!ok) {
@@ -23170,7 +23540,7 @@ ${result.stderr.split("\n").slice(-3).join("\n")}`);
   }
   for (const t of timings) logRow.durations_ms[t.label] = t.durationMs;
   const smokeStart = Date.now();
-  process.stdout.write(`  ${pc17.dim("smoke (docker create + inspect)".padEnd(34))}`);
+  process.stdout.write(`  ${pc18.dim("smoke (docker create + inspect)".padEnd(34))}`);
   const smokeImages = [
     "olam-auth:olam-next",
     "olam-devbox:olam-next",
@@ -23180,7 +23550,7 @@ ${result.stderr.split("\n").slice(-3).join("\n")}`);
   const smokeFailures = smokeResults.filter((r) => !r.ok);
   const smokeDurationMs = Date.now() - smokeStart;
   const smokeDur = `${(smokeDurationMs / 1e3).toFixed(1)}s`;
-  process.stdout.write(`${smokeFailures.length === 0 ? pc17.green("\u2713") : pc17.red("\u2717")} ${smokeDur}
+  process.stdout.write(`${smokeFailures.length === 0 ? pc18.green("\u2713") : pc18.red("\u2717")} ${smokeDur}
 `);
   timings.push({ label: "smoke", durationMs: smokeDurationMs });
   if (smokeFailures.length > 0) {
@@ -23207,12 +23577,12 @@ Recovery options:
     process.exitCode = 1;
     return;
   }
-  process.stdout.write(`  ${pc17.dim("atomic 6-tag swap".padEnd(34))}`);
+  process.stdout.write(`  ${pc18.dim("atomic 6-tag swap".padEnd(34))}`);
   const swapStart = Date.now();
   const swapResult = performAtomicSwap(PRODUCTION_SWAP_PLAN);
   const swapDurationMs = Date.now() - swapStart;
   const swapDur = `${(swapDurationMs / 1e3).toFixed(1)}s`;
-  process.stdout.write(`${swapResult.ok ? pc17.green("\u2713") : pc17.red("\u2717")} ${swapDur}
+  process.stdout.write(`${swapResult.ok ? pc18.green("\u2713") : pc18.red("\u2717")} ${swapDur}
 `);
   timings.push({ label: "atomic swap", durationMs: swapDurationMs });
   if (!swapResult.ok) {
@@ -23222,7 +23592,7 @@ Recovery options:
   }
   printInfo("Swap", swapResult.summary);
   const composeFile = findComposeFile();
-  process.stdout.write(`  ${pc17.dim("docker compose recreate".padEnd(34))}`);
+  process.stdout.write(`  ${pc18.dim("docker compose recreate".padEnd(34))}`);
   const composeStart = Date.now();
   const composeResult = runCompose(
     ["up", "-d", "--force-recreate"],
@@ -23232,7 +23602,7 @@ Recovery options:
   const composeDurationMs = Date.now() - composeStart;
   const composeOk = composeResult.ok;
   const composeDur = `${(composeDurationMs / 1e3).toFixed(1)}s`;
-  process.stdout.write(`${composeOk ? pc17.green("\u2713") : pc17.red("\u2717")} ${composeDur}
+  process.stdout.write(`${composeOk ? pc18.green("\u2713") : pc18.red("\u2717")} ${composeDur}
 `);
   timings.push({ label: "container recreate", durationMs: composeDurationMs });
   if (!composeOk) {
@@ -23248,10 +23618,10 @@ Recovery options:
     process.exitCode = 1;
     return;
   }
-  process.stdout.write(`  ${pc17.dim("recreate auth-service".padEnd(34))}`);
+  process.stdout.write(`  ${pc18.dim("recreate auth-service".padEnd(34))}`);
   const authResult = await recreateAuthService();
   const authDur = `${(authResult.durationMs / 1e3).toFixed(1)}s`;
-  process.stdout.write(`${authResult.ok ? pc17.green("\u2713") : pc17.red("\u2717")} ${authDur}
+  process.stdout.write(`${authResult.ok ? pc18.green("\u2713") : pc18.red("\u2717")} ${authDur}
 `);
   timings.push({ label: "auth recreate", durationMs: authResult.durationMs });
   if (!authResult.ok) {
@@ -23266,12 +23636,12 @@ Recovery options:
     process.exitCode = 1;
     return;
   }
-  process.stdout.write(`  ${pc17.dim("waiting for /health".padEnd(34))}`);
+  process.stdout.write(`  ${pc18.dim("waiting for /health".padEnd(34))}`);
   const healthStart = Date.now();
   const healthy = await waitForHealth(1e4);
   const healthDurationMs = Date.now() - healthStart;
   const healthDur = `${(healthDurationMs / 1e3).toFixed(1)}s`;
-  process.stdout.write(`${healthy ? pc17.green("\u2713") : pc17.yellow("?")} ${healthDur}
+  process.stdout.write(`${healthy ? pc18.green("\u2713") : pc18.yellow("?")} ${healthDur}
 `);
   timings.push({ label: "/health", durationMs: healthDurationMs });
   if (!healthy) {
@@ -23279,12 +23649,12 @@ Recovery options:
       "Host CP started but /health did not respond within 10s.\n  \u2022 Check: docker logs olam-host-cp\n  \u2022 If the new SHA is broken: `olam upgrade --rollback` restores the prior set in <30s."
     );
   }
-  process.stdout.write(`  ${pc17.dim("verify /version/status round-trip".padEnd(34))}`);
+  process.stdout.write(`  ${pc18.dim("verify /version/status round-trip".padEnd(34))}`);
   const versionStart = Date.now();
   const versionMatch = await waitForVersionMatch(_targetSha, 9e4);
   const versionDurationMs = Date.now() - versionStart;
   const versionDur = `${(versionDurationMs / 1e3).toFixed(1)}s`;
-  process.stdout.write(`${versionMatch.matched ? pc17.green("\u2713") : pc17.yellow("?")} ${versionDur}
+  process.stdout.write(`${versionMatch.matched ? pc18.green("\u2713") : pc18.yellow("?")} ${versionDur}
 `);
   timings.push({ label: "/version/status round-trip", durationMs: versionDurationMs });
   if (!versionMatch.matched) {
@@ -23358,16 +23728,16 @@ init_host_cp();
 init_context();
 init_output();
 import * as http3 from "node:http";
-import pc18 from "picocolors";
+import pc19 from "picocolors";
 var HOST_CP_PORT3 = 19e3;
 function colorLine(line) {
-  if (/\bERROR\b/.test(line)) return pc18.red(line);
-  if (/\bWARN\b/.test(line)) return pc18.yellow(line);
-  if (/\bINFO\b/.test(line)) return pc18.dim(line);
+  if (/\bERROR\b/.test(line)) return pc19.red(line);
+  if (/\bWARN\b/.test(line)) return pc19.yellow(line);
+  if (/\bINFO\b/.test(line)) return pc19.dim(line);
   return line;
 }
 function formatLine(line, service, showService) {
-  const prefix = showService && service ? `${pc18.cyan(`[${service}]`)} ` : "";
+  const prefix = showService && service ? `${pc19.cyan(`[${service}]`)} ` : "";
   return prefix + colorLine(line);
 }
 function parseSseEvent(raw) {
@@ -23484,7 +23854,7 @@ function registerLogs(program2) {
 // src/commands/ps.ts
 init_context();
 init_output();
-import pc19 from "picocolors";
+import pc20 from "picocolors";
 import { spawnSync as spawnSync12 } from "node:child_process";
 var SAFE_IDENT4 = /^[a-z0-9][a-z0-9-]{0,63}$/;
 function parseDockerTop(stdout) {
@@ -23545,18 +23915,18 @@ function printTable2(rows) {
   const fixedWidth = 5 + 1 + 8 + 1 + 6 + 1 + 6 + 1 + 10 + 1 + 6 + 1;
   const cmdWidth = Math.max(20, cols - fixedWidth);
   const header = [
-    pc19.bold(pc19.dim("PID".padEnd(5))),
-    pc19.bold(pc19.dim("USER".padEnd(8))),
-    pc19.bold(pc19.dim("%CPU".padEnd(6))),
-    pc19.bold(pc19.dim("%MEM".padEnd(6))),
-    pc19.bold(pc19.dim("STARTED".padEnd(10))),
-    pc19.bold(pc19.dim("STATE".padEnd(6))),
-    pc19.bold(pc19.dim("COMMAND"))
+    pc20.bold(pc20.dim("PID".padEnd(5))),
+    pc20.bold(pc20.dim("USER".padEnd(8))),
+    pc20.bold(pc20.dim("%CPU".padEnd(6))),
+    pc20.bold(pc20.dim("%MEM".padEnd(6))),
+    pc20.bold(pc20.dim("STARTED".padEnd(10))),
+    pc20.bold(pc20.dim("STATE".padEnd(6))),
+    pc20.bold(pc20.dim("COMMAND"))
   ].join(" ");
   console.log(header);
   for (const row of rows) {
     const cmd = row.command.length > cmdWidth ? row.command.slice(0, cmdWidth - 1) + "\u2026" : row.command;
-    const stateFn = row.state.startsWith("R") ? pc19.green : row.state.startsWith("Z") ? pc19.red : pc19.dim;
+    const stateFn = row.state.startsWith("R") ? pc20.green : row.state.startsWith("Z") ? pc20.red : pc20.dim;
     console.log([
       row.pid.padEnd(5),
       row.user.slice(0, 8).padEnd(8),
@@ -23605,7 +23975,7 @@ function registerPs(program2) {
       printTable2(rows);
       if (opts.watch) {
         process.stdout.write(`
-${pc19.dim(`world: ${worldId}  sort: ${sortKey}  refresh: 5s  Ctrl-C to exit`)}
+${pc20.dim(`world: ${worldId}  sort: ${sortKey}  refresh: 5s  Ctrl-C to exit`)}
 `);
       }
     }
@@ -23622,20 +23992,20 @@ ${pc19.dim(`world: ${worldId}  sort: ${sortKey}  refresh: 5s  Ctrl-C to exit`)}
 
 // src/commands/keys.ts
 init_output();
-import * as fs34 from "node:fs";
-import * as os20 from "node:os";
-import * as path37 from "node:path";
+import * as fs35 from "node:fs";
+import * as os21 from "node:os";
+import * as path38 from "node:path";
 import YAML6 from "yaml";
 function olamHome2() {
-  return process.env.OLAM_HOME ?? path37.join(os20.homedir(), ".olam");
+  return process.env.OLAM_HOME ?? path38.join(os21.homedir(), ".olam");
 }
 function keysFilePath() {
-  return path37.join(olamHome2(), "keys.yaml");
+  return path38.join(olamHome2(), "keys.yaml");
 }
 function readKeysFile() {
   const filePath = keysFilePath();
-  if (!fs34.existsSync(filePath)) return null;
-  const raw = fs34.readFileSync(filePath, "utf-8").trim();
+  if (!fs35.existsSync(filePath)) return null;
+  const raw = fs35.readFileSync(filePath, "utf-8").trim();
   if (raw.length === 0) return null;
   try {
     const parsed = YAML6.parse(raw);
@@ -23651,13 +24021,13 @@ function readKeysFile() {
 }
 function writeKeysFile(keys) {
   const dir = olamHome2();
-  if (!fs34.existsSync(dir)) {
-    fs34.mkdirSync(dir, { recursive: true });
+  if (!fs35.existsSync(dir)) {
+    fs35.mkdirSync(dir, { recursive: true });
   }
   const filePath = keysFilePath();
   const content = YAML6.stringify(keys);
-  fs34.writeFileSync(filePath, content, { encoding: "utf-8", mode: 384 });
-  fs34.chmodSync(filePath, 384);
+  fs35.writeFileSync(filePath, content, { encoding: "utf-8", mode: 384 });
+  fs35.chmodSync(filePath, 384);
 }
 function redact(value) {
   if (value.length <= 8) return value + "...";
@@ -23700,7 +24070,7 @@ function registerKeys(program2) {
       }
       const { [key]: _removed, ...rest } = existing;
       if (Object.keys(rest).length === 0) {
-        fs34.unlinkSync(keysFilePath());
+        fs35.unlinkSync(keysFilePath());
       } else {
         writeKeysFile(rest);
       }
@@ -23725,10 +24095,10 @@ function registerKeys(program2) {
 // src/commands/world-snapshot.ts
 init_snapshot();
 init_output();
-import * as fs35 from "node:fs";
-import * as path38 from "node:path";
+import * as fs36 from "node:fs";
+import * as path39 from "node:path";
 import { execSync as execSync11 } from "node:child_process";
-import pc20 from "picocolors";
+import pc21 from "picocolors";
 
 // src/commands/world.ts
 function getOrCreateWorldCommand(program2) {
@@ -23749,16 +24119,16 @@ function emitDeprecationWarning(subcommand) {
 }
 function bumpDeprecationCounter() {
   if (process.env[INTERNAL_SENTINEL_ENV] === "1") return;
-  const counterPath = path38.join(snapshotsDir(), ".deprecation-counter");
+  const counterPath = path39.join(snapshotsDir(), ".deprecation-counter");
   try {
-    fs35.mkdirSync(path38.dirname(counterPath), { recursive: true });
+    fs36.mkdirSync(path39.dirname(counterPath), { recursive: true });
     let current = 0;
-    if (fs35.existsSync(counterPath)) {
-      const raw = fs35.readFileSync(counterPath, "utf-8").trim();
+    if (fs36.existsSync(counterPath)) {
+      const raw = fs36.readFileSync(counterPath, "utf-8").trim();
       const parsed = parseInt(raw, 10);
       if (Number.isInteger(parsed) && parsed >= 0) current = parsed;
     }
-    fs35.writeFileSync(counterPath, String(current + 1), { mode: 384 });
+    fs36.writeFileSync(counterPath, String(current + 1), { mode: 384 });
   } catch {
   }
 }
@@ -23820,7 +24190,7 @@ async function handleCreate2(worldId, kindArg) {
     const label = r.repo ? `${r.kind}/${r.repo}` : r.kind;
     if (r.ok) {
       printSuccess(`${label}`);
-      console.log(`         ${pc20.dim(r.tarPath)}`);
+      console.log(`         ${pc21.dim(r.tarPath)}`);
     } else {
       printWarning(`${label}: ${r.msg ?? "skipped"}`);
     }
@@ -23834,17 +24204,17 @@ function resolveKinds(arg) {
   return [];
 }
 async function captureGems(worldId, workspacePath, repo) {
-  const repoDir = path38.join(workspacePath, repo);
+  const repoDir = path39.join(workspacePath, repo);
   const fingerprint = computeGemsFingerprint(repoDir);
   if (!fingerprint) {
     return { ok: false, tarPath: "", msg: "no Gemfile.lock \u2014 layer does not apply" };
   }
   const tarPath = snapshotTarPath(worldId, "gems", repo, fingerprint);
-  const vendorBundle = path38.join(repoDir, "vendor", "bundle");
-  if (fs35.existsSync(vendorBundle)) {
+  const vendorBundle = path39.join(repoDir, "vendor", "bundle");
+  if (fs36.existsSync(vendorBundle)) {
     try {
       packTarball(vendorBundle, tarPath);
-      const stat = fs35.statSync(tarPath);
+      const stat = fs36.statSync(tarPath);
       const manifest = {
         kind: "gems",
         worldId,
@@ -23877,10 +24247,10 @@ async function captureGems(worldId, workspacePath, repo) {
       `docker exec ${containerName} sh -c 'mkdir -p "$(dirname ${tmpTar})" && tar -czf ${tmpTar}.tmp -C ${bundlePath} . && mv ${tmpTar}.tmp ${tmpTar}'`,
       { stdio: "pipe", timeout: 12e4 }
     );
-    fs35.mkdirSync(path38.dirname(tarPath), { recursive: true });
+    fs36.mkdirSync(path39.dirname(tarPath), { recursive: true });
     execSync11(`docker cp ${containerName}:${tmpTar} "${tarPath}"`, { stdio: "pipe", timeout: 12e4 });
     execSync11(`docker exec ${containerName} rm -f ${tmpTar}`, { stdio: "pipe" });
-    const stat = fs35.statSync(tarPath);
+    const stat = fs36.statSync(tarPath);
     const manifest = {
       kind: "gems",
       worldId,
@@ -23897,19 +24267,19 @@ async function captureGems(worldId, workspacePath, repo) {
   }
 }
 async function captureNode(worldId, workspacePath, repo) {
-  const repoDir = path38.join(workspacePath, repo);
+  const repoDir = path39.join(workspacePath, repo);
   const fingerprint = computeNodeFingerprint(repoDir);
   if (!fingerprint) {
     return { ok: false, tarPath: "", msg: "no lockfile \u2014 layer does not apply" };
   }
-  const nodeModules = path38.join(repoDir, "node_modules");
-  if (!fs35.existsSync(nodeModules)) {
+  const nodeModules = path39.join(repoDir, "node_modules");
+  if (!fs36.existsSync(nodeModules)) {
     return { ok: false, tarPath: "", msg: "node_modules not installed yet" };
   }
   const tarPath = snapshotTarPath(worldId, "node", repo, fingerprint);
   try {
     packTarball(nodeModules, tarPath);
-    const stat = fs35.statSync(tarPath);
+    const stat = fs36.statSync(tarPath);
     const manifest = {
       kind: "node",
       worldId,
@@ -23926,7 +24296,7 @@ async function captureNode(worldId, workspacePath, repo) {
   }
 }
 async function capturePg(worldId, workspacePath, repoNames) {
-  const repoDirs = repoNames.map((r) => path38.join(workspacePath, r));
+  const repoDirs = repoNames.map((r) => path39.join(workspacePath, r));
   const fingerprint = computePgFingerprint(repoDirs);
   if (!fingerprint) {
     return { ok: false, tarPath: "", msg: "no Gemfile.lock / schema.rb \u2014 layer does not apply" };
@@ -23941,13 +24311,13 @@ async function capturePg(worldId, workspacePath, repoNames) {
   }
   try {
     execSync11(`docker stop ${containerName}`, { stdio: "pipe", timeout: 3e4 });
-    fs35.mkdirSync(path38.dirname(tarPath), { recursive: true });
+    fs36.mkdirSync(path39.dirname(tarPath), { recursive: true });
     execSync11(
-      `docker run --rm         -v "${volumeName2}:/pgdata:ro"         -v "${path38.dirname(tarPath)}:/dest"         alpine         sh -c 'tar -czf /dest/${path38.basename(tarPath)}.tmp -C /pgdata . && mv /dest/${path38.basename(tarPath)}.tmp /dest/${path38.basename(tarPath)}'`,
+      `docker run --rm         -v "${volumeName2}:/pgdata:ro"         -v "${path39.dirname(tarPath)}:/dest"         alpine         sh -c 'tar -czf /dest/${path39.basename(tarPath)}.tmp -C /pgdata . && mv /dest/${path39.basename(tarPath)}.tmp /dest/${path39.basename(tarPath)}'`,
       { stdio: "pipe", timeout: 18e4 }
     );
     execSync11(`docker start ${containerName}`, { stdio: "pipe", timeout: 3e4 });
-    const stat = fs35.statSync(tarPath);
+    const stat = fs36.statSync(tarPath);
     const manifest = {
       kind: "pg",
       worldId,
@@ -23971,18 +24341,18 @@ async function handleEvict(opts) {
   const maxBytes = Number.isInteger(cap) && cap > 0 ? cap : 5 * 1024 * 1024 * 1024;
   if (opts.dryRun) {
     const root = snapshotsDir();
-    if (!fs35.existsSync(root)) {
-      console.log(pc20.dim("No snapshot dir; nothing to evict."));
+    if (!fs36.existsSync(root)) {
+      console.log(pc21.dim("No snapshot dir; nothing to evict."));
       return;
     }
     const allTars = [];
     const walk2 = (d) => {
-      for (const entry of fs35.readdirSync(d, { withFileTypes: true })) {
-        const full = path38.join(d, entry.name);
+      for (const entry of fs36.readdirSync(d, { withFileTypes: true })) {
+        const full = path39.join(d, entry.name);
         if (entry.isDirectory()) {
           walk2(full);
         } else if (entry.name.endsWith(".tar.gz")) {
-          const stat = fs35.statSync(full);
+          const stat = fs36.statSync(full);
           allTars.push({ path: full, size: stat.size, mtime: stat.mtimeMs });
         }
       }
@@ -23990,7 +24360,7 @@ async function handleEvict(opts) {
     walk2(root);
     const total = allTars.reduce((a, t) => a + t.size, 0);
     if (total <= maxBytes) {
-      console.log(`${formatBytes2(total)} total \u2264 ${formatBytes2(maxBytes)} cap; nothing to evict.`);
+      console.log(`${formatBytes3(total)} total \u2264 ${formatBytes3(maxBytes)} cap; nothing to evict.`);
       return;
     }
     allTars.sort((a, b) => a.mtime - b.mtime);
@@ -24001,21 +24371,21 @@ async function handleEvict(opts) {
       toEvict.push(t);
       remaining -= t.size;
     }
-    printHeader(`Would evict ${toEvict.length} snapshot(s) (${formatBytes2(total - remaining)})`);
+    printHeader(`Would evict ${toEvict.length} snapshot(s) (${formatBytes3(total - remaining)})`);
     console.log();
     for (const t of toEvict) {
       const age = formatAge2(Date.now() - t.mtime);
-      console.log(`  ${pc20.dim(formatBytes2(t.size).padStart(8))}  ${age.padStart(10)}  ${t.path}`);
+      console.log(`  ${pc21.dim(formatBytes3(t.size).padStart(8))}  ${age.padStart(10)}  ${t.path}`);
     }
     console.log();
-    console.log(pc20.dim(`Total after eviction: ${formatBytes2(remaining)} (cap: ${formatBytes2(maxBytes)})`));
+    console.log(pc21.dim(`Total after eviction: ${formatBytes3(remaining)} (cap: ${formatBytes3(maxBytes)})`));
     return;
   }
   const freed = evictOldSnapshotsWithFlock(maxBytes);
   if (freed > 0) {
-    printSuccess(`Evicted ${formatBytes2(freed)} (cap: ${formatBytes2(maxBytes)})`);
+    printSuccess(`Evicted ${formatBytes3(freed)} (cap: ${formatBytes3(maxBytes)})`);
   } else {
-    console.log(pc20.dim("No eviction needed (or another process held the lock)."));
+    console.log(pc21.dim("No eviction needed (or another process held the lock)."));
   }
 }
 function handleList2(worldIdFilter) {
@@ -24023,7 +24393,7 @@ function handleList2(worldIdFilter) {
   const entries = listSnapshots(worldIdFilter);
   if (entries.length === 0) {
     const where = worldIdFilter ? ` for world "${worldIdFilter}"` : "";
-    console.log(pc20.dim(`No snapshots found${where}. Run \`olam world snapshot create <worldId>\` first.`));
+    console.log(pc21.dim(`No snapshots found${where}. Run \`olam world snapshot create <worldId>\` first.`));
     return;
   }
   printHeader(`${entries.length} snapshot(s)`);
@@ -24032,15 +24402,15 @@ function handleList2(worldIdFilter) {
   for (const entry of entries) {
     const { manifest } = entry;
     if (manifest.worldId !== lastWorldId) {
-      console.log(pc20.bold(manifest.worldId));
+      console.log(pc21.bold(manifest.worldId));
       lastWorldId = manifest.worldId;
     }
     const repo = manifest.repo ?? "(all repos)";
-    const size = formatBytes2(manifest.sizeBytes);
+    const size = formatBytes3(manifest.sizeBytes);
     const age = formatAge2(entry.ageMs);
-    const kindColor = manifest.kind === "gems" ? pc20.magenta(manifest.kind) : manifest.kind === "node" ? pc20.cyan(manifest.kind) : pc20.yellow(manifest.kind);
+    const kindColor = manifest.kind === "gems" ? pc21.magenta(manifest.kind) : manifest.kind === "node" ? pc21.cyan(manifest.kind) : pc21.yellow(manifest.kind);
     console.log(
-      `  ${kindColor.padEnd(6)}  ${pc20.dim(repo.padEnd(24))}  ${manifest.fingerprint}  ${size.padStart(8)}  ${age}`
+      `  ${kindColor.padEnd(6)}  ${pc21.dim(repo.padEnd(24))}  ${manifest.fingerprint}  ${size.padStart(8)}  ${age}`
     );
   }
   console.log();
@@ -24057,7 +24427,7 @@ async function loadWorldMeta(worldId) {
   }
   return { workspacePath: world.workspacePath, repoNames: [...world.repos] };
 }
-function formatBytes2(bytes) {
+function formatBytes3(bytes) {
   if (bytes < 1024) return `${bytes}B`;
   if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
   if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
@@ -24075,35 +24445,35 @@ function formatAge2(ms) {
 // src/commands/refresh.ts
 init_context();
 init_output();
-import * as fs37 from "node:fs";
-import * as os21 from "node:os";
-import * as path40 from "node:path";
+import * as fs38 from "node:fs";
+import * as os22 from "node:os";
+import * as path41 from "node:path";
 import { spawnSync as spawnSync13 } from "node:child_process";
 import ora8 from "ora";
 
 // src/commands/refresh-helpers.ts
-import * as fs36 from "node:fs";
-import * as path39 from "node:path";
+import * as fs37 from "node:fs";
+import * as path40 from "node:path";
 function collectCpSourceFiles(standaloneDir) {
-  if (!fs36.existsSync(standaloneDir)) {
+  if (!fs37.existsSync(standaloneDir)) {
     throw new Error(`CP standalone dir not found: ${standaloneDir}`);
   }
   const entries = [];
-  const topLevel = fs36.readdirSync(standaloneDir).filter((f) => {
-    const stat = fs36.statSync(path39.join(standaloneDir, f));
+  const topLevel = fs37.readdirSync(standaloneDir).filter((f) => {
+    const stat = fs37.statSync(path40.join(standaloneDir, f));
     return stat.isFile() && f.endsWith(".mjs") && !f.endsWith(".test.mjs");
   }).sort();
   for (const f of topLevel) {
-    entries.push({ srcPath: path39.join(standaloneDir, f), destRelPath: f });
+    entries.push({ srcPath: path40.join(standaloneDir, f), destRelPath: f });
   }
-  const libDir = path39.join(standaloneDir, "lib");
-  if (fs36.existsSync(libDir) && fs36.statSync(libDir).isDirectory()) {
-    const libFiles = fs36.readdirSync(libDir).filter((f) => {
-      const stat = fs36.statSync(path39.join(libDir, f));
+  const libDir = path40.join(standaloneDir, "lib");
+  if (fs37.existsSync(libDir) && fs37.statSync(libDir).isDirectory()) {
+    const libFiles = fs37.readdirSync(libDir).filter((f) => {
+      const stat = fs37.statSync(path40.join(libDir, f));
       return stat.isFile() && f.endsWith(".mjs") && !f.endsWith(".test.mjs");
     }).sort();
     for (const f of libFiles) {
-      entries.push({ srcPath: path39.join(libDir, f), destRelPath: `lib/${f}` });
+      entries.push({ srcPath: path40.join(libDir, f), destRelPath: `lib/${f}` });
     }
   }
   return entries;
@@ -24161,16 +24531,16 @@ async function refreshWorld(worldId, portOffset, standaloneDir, opts) {
       error: err instanceof Error ? err.message : String(err)
     };
   }
-  const stagingDir = fs37.mkdtempSync(
-    path40.join(os21.tmpdir(), `olam-refresh-${worldId}-`)
+  const stagingDir = fs38.mkdtempSync(
+    path41.join(os22.tmpdir(), `olam-refresh-${worldId}-`)
   );
   try {
     const hasLib = entries.some((e) => e.destRelPath.startsWith("lib/"));
     if (hasLib) {
-      fs37.mkdirSync(path40.join(stagingDir, "lib"), { recursive: true });
+      fs38.mkdirSync(path41.join(stagingDir, "lib"), { recursive: true });
     }
     for (const { srcPath, destRelPath } of entries) {
-      fs37.copyFileSync(srcPath, path40.join(stagingDir, destRelPath));
+      fs38.copyFileSync(srcPath, path41.join(stagingDir, destRelPath));
     }
     const cpResult = docker([
       "cp",
@@ -24185,7 +24555,7 @@ async function refreshWorld(worldId, portOffset, standaloneDir, opts) {
       };
     }
   } finally {
-    fs37.rmSync(stagingDir, { recursive: true, force: true });
+    fs38.rmSync(stagingDir, { recursive: true, force: true });
   }
   if (opts.restart) {
     const restartResult = docker([
@@ -24222,11 +24592,11 @@ function registerRefresh(program2) {
       process.exitCode = 1;
       return;
     }
-    const standaloneDir = path40.join(
+    const standaloneDir = path41.join(
       process.cwd(),
       "packages/control-plane/standalone"
     );
-    if (!fs37.existsSync(standaloneDir)) {
+    if (!fs38.existsSync(standaloneDir)) {
       printError(
         `CP standalone source not found at ${standaloneDir}.
 Run \`olam refresh\` from the olam repo root.`
@@ -24305,11 +24675,11 @@ Run \`olam refresh\` from the olam repo root.`
 }
 
 // src/commands/diagnose.ts
-import * as fs38 from "node:fs";
-import * as os22 from "node:os";
-import * as path41 from "node:path";
-import { execFileSync as execFileSync8, execSync as execSync12 } from "node:child_process";
-import pc21 from "picocolors";
+import * as fs39 from "node:fs";
+import * as os23 from "node:os";
+import * as path42 from "node:path";
+import { execFileSync as execFileSync9, execSync as execSync12 } from "node:child_process";
+import pc22 from "picocolors";
 
 // ../core/dist/diagnose/secret-stripper.js
 var SECRET_PATTERNS = [
@@ -24342,9 +24712,9 @@ function stripSecrets(input) {
 }
 
 // src/commands/diagnose.ts
-var DIAGNOSTICS_DIR = path41.join(os22.homedir(), ".olam", "diagnostics");
-var LOG_DIR = path41.join(os22.homedir(), ".olam", "log");
-var CACHE_DIR = path41.join(os22.homedir(), ".olam", "cache");
+var DIAGNOSTICS_DIR = path42.join(os23.homedir(), ".olam", "diagnostics");
+var LOG_DIR = path42.join(os23.homedir(), ".olam", "log");
+var CACHE_DIR = path42.join(os23.homedir(), ".olam", "cache");
 var LOG_TAIL_LINES = 200;
 function safeExec(cmd) {
   try {
@@ -24354,14 +24724,14 @@ function safeExec(cmd) {
   }
 }
 function defaultZip(zipPath, files) {
-  execFileSync8("zip", ["-j", zipPath, ...files]);
+  execFileSync9("zip", ["-j", zipPath, ...files]);
 }
 async function buildDiagnosticsZip(_exec = (cmd) => safeExec(cmd), _outDir = DIAGNOSTICS_DIR, _logDir = LOG_DIR, _zip = defaultZip) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 23);
-  const zipPath = path41.join(_outDir, `olam-diag-${ts}.zip`);
-  const tmpDir = fs38.mkdtempSync(path41.join(os22.tmpdir(), "olam-diag-"));
+  const zipPath = path42.join(_outDir, `olam-diag-${ts}.zip`);
+  const tmpDir = fs39.mkdtempSync(path42.join(os23.tmpdir(), "olam-diag-"));
   try {
-    fs38.mkdirSync(_outDir, { recursive: true });
+    fs39.mkdirSync(_outDir, { recursive: true });
     const entries = [];
     const version = process.env["OLAM_CLI_VERSION"] ?? "unknown";
     const nodeVersion = process.version;
@@ -24372,19 +24742,19 @@ platform: ${platform}
 `;
     _writeEntry(tmpDir, "version.txt", stripSecrets(versionContent), entries);
     const osContent = [
-      `os: ${os22.type()} ${os22.release()}`,
-      `arch: ${os22.arch()}`,
-      `uptime: ${os22.uptime()}s`
+      `os: ${os23.type()} ${os23.release()}`,
+      `arch: ${os23.arch()}`,
+      `uptime: ${os23.uptime()}s`
     ].join("\n") + "\n";
     _writeEntry(tmpDir, "os-info.txt", stripSecrets(osContent), entries);
-    const depsFile = path41.join(CACHE_DIR, "deps.json");
-    if (fs38.existsSync(depsFile)) {
-      const deps = fs38.readFileSync(depsFile, "utf-8");
+    const depsFile = path42.join(CACHE_DIR, "deps.json");
+    if (fs39.existsSync(depsFile)) {
+      const deps = fs39.readFileSync(depsFile, "utf-8");
       _writeEntry(tmpDir, "deps.json", stripSecrets(deps), entries);
     }
     const latestLog = _latestLog(_logDir);
     if (latestLog) {
-      const lines = fs38.readFileSync(latestLog, "utf-8").split("\n");
+      const lines = fs39.readFileSync(latestLog, "utf-8").split("\n");
       const tail = lines.slice(-LOG_TAIL_LINES).join("\n");
       _writeEntry(tmpDir, "log-tail.txt", stripSecrets(tail), entries);
     }
@@ -24396,38 +24766,38 @@ platform: ${platform}
     if (authAudit) {
       _writeEntry(tmpDir, "audit-auth-callers.txt", stripSecrets(authAudit), entries);
     }
-    const fileArgs = entries.map((e) => path41.join(tmpDir, e));
+    const fileArgs = entries.map((e) => path42.join(tmpDir, e));
     try {
       _zip(zipPath, fileArgs);
     } catch (err) {
       throw new Error(`zip command produced no output file. zip stderr: ${err.message}`);
     }
-    if (!fs38.existsSync(zipPath)) {
+    if (!fs39.existsSync(zipPath)) {
       throw new Error("zip command produced no output file.");
     }
     return { zipPath, entries };
   } finally {
     try {
-      fs38.rmSync(tmpDir, { recursive: true, force: true });
+      fs39.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
 }
 function _writeEntry(dir, name, content, entries) {
-  fs38.writeFileSync(path41.join(dir, name), content, { mode: 420 });
+  fs39.writeFileSync(path42.join(dir, name), content, { mode: 420 });
   entries.push(name);
 }
 function _latestLog(logDir) {
-  if (!fs38.existsSync(logDir)) return null;
-  const files = fs38.readdirSync(logDir).filter((f) => f.startsWith("host-")).sort().reverse();
-  return files.length > 0 ? path41.join(logDir, files[0]) : null;
+  if (!fs39.existsSync(logDir)) return null;
+  const files = fs39.readdirSync(logDir).filter((f) => f.startsWith("host-")).sort().reverse();
+  return files.length > 0 ? path42.join(logDir, files[0]) : null;
 }
 async function buildTelemetryPayload() {
   const channel = "stable";
-  const manifestFile = path41.join(CACHE_DIR, "manifest.json");
+  const manifestFile = path42.join(CACHE_DIR, "manifest.json");
   let manifestAgeHours = null;
-  if (fs38.existsSync(manifestFile)) {
-    const mtime = fs38.statSync(manifestFile).mtime.getTime();
+  if (fs39.existsSync(manifestFile)) {
+    const mtime = fs39.statSync(manifestFile).mtime.getTime();
     manifestAgeHours = Math.round((Date.now() - mtime) / 36e5);
   }
   return {
@@ -24447,47 +24817,47 @@ function registerDiagnose(program2) {
       return;
     }
     if (!opts.quiet) {
-      console.log(pc21.cyan("Building diagnostics zip\u2026"));
+      console.log(pc22.cyan("Building diagnostics zip\u2026"));
     }
     try {
       const { zipPath, entries } = await buildDiagnosticsZip();
       if (!opts.quiet) {
-        console.log(pc21.green(`Done: ${zipPath}`));
-        console.log(pc21.dim(`Contents: ${entries.join(", ")}`));
+        console.log(pc22.green(`Done: ${zipPath}`));
+        console.log(pc22.dim(`Contents: ${entries.join(", ")}`));
       }
       if (opts.upload) {
-        console.log(pc21.yellow(
+        console.log(pc22.yellow(
           `Telemetry endpoint not yet provisioned. Share the zip manually:
   File: ${zipPath}
   See docs/runbooks/share-diagnostics.md for instructions.`
         ));
       }
     } catch (err) {
-      console.error(pc21.red(`Diagnose failed: ${err.message}`));
+      console.error(pc22.red(`Diagnose failed: ${err.message}`));
       process.exitCode = 1;
     }
   });
 }
 
 // src/commands/update.ts
-import * as fs41 from "node:fs";
-import * as os24 from "node:os";
-import * as path44 from "node:path";
+import * as fs42 from "node:fs";
+import * as os25 from "node:os";
+import * as path45 from "node:path";
 import { execSync as execSync13 } from "node:child_process";
-import pc22 from "picocolors";
+import pc23 from "picocolors";
 
 // src/lib/symlink-reconcile.ts
-import * as fs39 from "node:fs";
-import * as path42 from "node:path";
+import * as fs40 from "node:fs";
+import * as path43 from "node:path";
 var realFs = {
-  readdirSync: (p) => fs39.readdirSync(p),
-  existsSync: (p) => fs39.existsSync(p),
-  lstatSync: (p) => fs39.lstatSync(p),
-  readlinkSync: (p) => fs39.readlinkSync(p),
-  symlinkSync: (t, l) => fs39.symlinkSync(t, l),
-  unlinkSync: (p) => fs39.unlinkSync(p),
+  readdirSync: (p) => fs40.readdirSync(p),
+  existsSync: (p) => fs40.existsSync(p),
+  lstatSync: (p) => fs40.lstatSync(p),
+  readlinkSync: (p) => fs40.readlinkSync(p),
+  symlinkSync: (t, l) => fs40.symlinkSync(t, l),
+  unlinkSync: (p) => fs40.unlinkSync(p),
   mkdirSync: (p, o) => {
-    fs39.mkdirSync(p, o);
+    fs40.mkdirSync(p, o);
   }
 };
 function reconcileSkillSymlinks(npmSkillsDir, claudeSkillsDir, _fs = realFs) {
@@ -24497,8 +24867,8 @@ function reconcileSkillSymlinks(npmSkillsDir, claudeSkillsDir, _fs = realFs) {
   _fs.mkdirSync(claudeSkillsDir, { recursive: true });
   const sourceSkills = _fs.existsSync(npmSkillsDir) ? _fs.readdirSync(npmSkillsDir).filter((d) => d.startsWith("olam-")) : [];
   for (const skill of sourceSkills) {
-    const linkPath = path42.join(claudeSkillsDir, skill);
-    const target = path42.join(npmSkillsDir, skill);
+    const linkPath = path43.join(claudeSkillsDir, skill);
+    const target = path43.join(npmSkillsDir, skill);
     if (!_fs.existsSync(linkPath)) {
       try {
         _fs.symlinkSync(target, linkPath);
@@ -24511,7 +24881,7 @@ function reconcileSkillSymlinks(npmSkillsDir, claudeSkillsDir, _fs = realFs) {
   }
   const deployedEntries = _fs.existsSync(claudeSkillsDir) ? _fs.readdirSync(claudeSkillsDir).filter((d) => d.startsWith("olam-")) : [];
   for (const entry of deployedEntries) {
-    const linkPath = path42.join(claudeSkillsDir, entry);
+    const linkPath = path43.join(claudeSkillsDir, entry);
     let isSymlink = false;
     try {
       isSymlink = _fs.lstatSync(linkPath).isSymbolicLink();
@@ -24536,9 +24906,9 @@ function reconcileSkillSymlinks(npmSkillsDir, claudeSkillsDir, _fs = realFs) {
 
 // src/commands/update.ts
 var PACKAGE_NAME = "@pleri/olam-cli";
-var CACHE_DIR2 = path44.join(os24.homedir(), ".olam", "cache");
-var LOG_DIR2 = path44.join(os24.homedir(), ".olam", "log");
-var LAST_STABLE_FILE = path44.join(CACHE_DIR2, "last-stable.txt");
+var CACHE_DIR2 = path45.join(os25.homedir(), ".olam", "cache");
+var LOG_DIR2 = path45.join(os25.homedir(), ".olam", "log");
+var LAST_STABLE_FILE = path45.join(CACHE_DIR2, "last-stable.txt");
 function defaultExec(cmd) {
   try {
     const stdout = execSync13(cmd, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
@@ -24560,22 +24930,22 @@ function getCurrentVersion(_exec = defaultExec) {
 }
 function readLastStable(file = LAST_STABLE_FILE) {
   try {
-    const v = fs41.readFileSync(file, "utf-8").trim();
+    const v = fs42.readFileSync(file, "utf-8").trim();
     return v || null;
   } catch {
     return null;
   }
 }
 function writeLastStable(version, file = LAST_STABLE_FILE) {
-  fs41.mkdirSync(path44.dirname(file), { recursive: true });
-  fs41.writeFileSync(file, version, { mode: 420 });
+  fs42.mkdirSync(path45.dirname(file), { recursive: true });
+  fs42.writeFileSync(file, version, { mode: 420 });
 }
 function logUpdateFailure(stderr) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const logFile = path44.join(LOG_DIR2, `update-${ts}.log`);
+  const logFile = path45.join(LOG_DIR2, `update-${ts}.log`);
   try {
-    fs41.mkdirSync(LOG_DIR2, { recursive: true });
-    fs41.appendFileSync(logFile, `[update-failure ${(/* @__PURE__ */ new Date()).toISOString()}]
+    fs42.mkdirSync(LOG_DIR2, { recursive: true });
+    fs42.appendFileSync(logFile, `[update-failure ${(/* @__PURE__ */ new Date()).toISOString()}]
 ${stderr}
 `, "utf-8");
   } catch {
@@ -24626,52 +24996,52 @@ async function doUpdate(opts, _exec = defaultExec, _reconcile = reconcileSkillSy
     writeLastStable(prevVersion);
   }
   if (!quiet) {
-    console.log(pc22.cyan(`Installing ${PACKAGE_NAME}@${channel}\u2026`));
+    console.log(pc23.cyan(`Installing ${PACKAGE_NAME}@${channel}\u2026`));
   }
   const installResult = _exec(`npm install -g ${PACKAGE_NAME}@${channel}`);
   if (installResult.exitCode !== 0) {
     logUpdateFailure(installResult.stderr);
     if (!quiet) {
-      console.error(pc22.red("Update failed."));
+      console.error(pc23.red("Update failed."));
     }
     const prev = readLastStable();
     if (prev) {
       if (!quiet) {
-        console.log(pc22.yellow(`Restoring to ${prev}\u2026`));
+        console.log(pc23.yellow(`Restoring to ${prev}\u2026`));
       }
       const restoreResult = _exec(`npm install -g ${PACKAGE_NAME}@${prev}`);
       if (restoreResult.exitCode !== 0) {
         if (!quiet) {
-          console.error(pc22.red(
+          console.error(pc23.red(
             `Restore also failed. Run: npm install -g ${PACKAGE_NAME}@${prev} manually.`
           ));
         }
       } else if (!quiet) {
-        console.log(pc22.yellow(`Restored to ${prev}.`));
+        console.log(pc23.yellow(`Restored to ${prev}.`));
       }
     } else if (!quiet) {
-      console.error(pc22.red("No previous version cached; cannot auto-restore."));
+      console.error(pc23.red("No previous version cached; cannot auto-restore."));
     }
     return { action: "restored", prevVersion: prev ?? void 0, exitCode: 11 };
   }
   const newVersion = getCurrentVersion(_exec) ?? void 0;
   if (!quiet && newVersion) {
-    console.log(pc22.green(`Updated to ${newVersion}.`));
+    console.log(pc23.green(`Updated to ${newVersion}.`));
   }
   const npmRootResult = _getNpmRoot("npm root -g");
   let symlinkResult = { added: [], removed: [] };
   if (npmRootResult.exitCode === 0) {
     const npmRoot = npmRootResult.stdout.trim();
-    const npmSkillsDir = path44.join(npmRoot, "@pleri", "olam-cli", "plugin", "skills");
-    const claudeSkillsDir = path44.join(os24.homedir(), ".claude", "skills");
+    const npmSkillsDir = path45.join(npmRoot, "@pleri", "olam-cli", "plugin", "skills");
+    const claudeSkillsDir = path45.join(os25.homedir(), ".claude", "skills");
     const rec = _reconcile(npmSkillsDir, claudeSkillsDir);
     symlinkResult = { added: rec.added, removed: rec.removed };
     if (!quiet && (rec.added.length > 0 || rec.removed.length > 0)) {
       if (rec.added.length > 0) {
-        console.log(pc22.dim(`Skills added: ${rec.added.join(", ")}`));
+        console.log(pc23.dim(`Skills added: ${rec.added.join(", ")}`));
       }
       if (rec.removed.length > 0) {
-        console.log(pc22.dim(`Skills removed (dangling): ${rec.removed.join(", ")}`));
+        console.log(pc23.dim(`Skills removed (dangling): ${rec.removed.join(", ")}`));
       }
     }
   }
@@ -24709,8 +25079,8 @@ async function doRollback(_exec = defaultExec, _reconcile = reconcileSkillSymlin
   if (npmRootResult.exitCode === 0) {
     const npmRoot = npmRootResult.stdout.trim();
     _reconcile(
-      path44.join(npmRoot, "@pleri", "olam-cli", "plugin", "skills"),
-      path44.join(os24.homedir(), ".claude", "skills")
+      path45.join(npmRoot, "@pleri", "olam-cli", "plugin", "skills"),
+      path45.join(os25.homedir(), ".claude", "skills")
     );
   }
   return { action: "rolled-back", restoredVersion: prev, exitCode: 0 };
@@ -24765,7 +25135,7 @@ function registerUpdate(program2) {
 // src/commands/begin.ts
 init_host_cp();
 init_open_url();
-import pc23 from "picocolors";
+import pc24 from "picocolors";
 async function doBegin(opts, _startFn = startHostCp, _openFn = openUrl) {
   const prevExitCode = process.exitCode;
   await _startFn({ showToken: opts.showToken });
@@ -24775,7 +25145,7 @@ async function doBegin(opts, _startFn = startHostCp, _openFn = openUrl) {
     const token = readToken();
     if (token) {
       const base = `http://127.0.0.1:${HOST_CP_PORT}/`;
-      console.log(pc23.dim(`Opening ${base}`));
+      console.log(pc24.dim(`Opening ${base}`));
       _openFn(`${base}?token=${token}`);
     }
   }
@@ -24791,7 +25161,7 @@ function registerBegin(program2) {
 }
 
 // src/commands/config.ts
-import * as fs43 from "node:fs";
+import * as fs44 from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
 
 // ../core/dist/global-config/index.js
@@ -24800,12 +25170,12 @@ init_store2();
 
 // ../core/dist/global-config/repos.js
 init_store2();
-import * as fs42 from "node:fs";
-import * as os25 from "node:os";
-import * as path45 from "node:path";
+import * as fs43 from "node:fs";
+import * as os26 from "node:os";
+import * as path46 from "node:path";
 function expandPath(p) {
   if (p === "~" || p.startsWith("~/")) {
-    return path45.join(os25.homedir(), p.slice(1));
+    return path46.join(os26.homedir(), p.slice(1));
   }
   return p;
 }
@@ -24818,7 +25188,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 (!fs42.existsSync(resolvedPath)) {
+  if (!fs43.existsSync(resolvedPath)) {
     throw new Error(`path "${entry.path}" does not exist. Verify the path is correct.`);
   }
   const now = Date.now();
@@ -24847,7 +25217,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 && !fs42.existsSync(resolvedUpdatePath)) {
+  if (resolvedUpdatePath !== void 0 && !fs43.existsSync(resolvedUpdatePath)) {
     throw new Error(`path "${updates.path}" does not exist. Verify the path is correct.`);
   }
   const existing = config.repos[idx];
@@ -24877,14 +25247,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 (!fs43.existsSync(resolvedPath)) {
+    if (!fs44.existsSync(resolvedPath)) {
       process.stderr.write(`config file not found: ${resolvedPath}
 `);
       process.exit(1);
     }
     let raw;
     try {
-      raw = fs43.readFileSync(resolvedPath, "utf-8");
+      raw = fs44.readFileSync(resolvedPath, "utf-8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       process.stderr.write(`cannot read ${resolvedPath}: ${msg}
@@ -24920,7 +25290,7 @@ function registerConfig(program2) {
 }
 
 // src/commands/repos.ts
-import pc24 from "picocolors";
+import pc25 from "picocolors";
 init_output();
 function asMessage(err) {
   return err instanceof Error ? err.message : String(err);
@@ -24930,14 +25300,14 @@ function registerRepos(program2) {
   repos.command("list").description("List all registered repos").action(() => {
     const all = listRepos();
     if (all.length === 0) {
-      console.log(pc24.dim("0 repo(s) registered. Add one with: olam repos add --name <n> --path <p>"));
+      console.log(pc25.dim("0 repo(s) registered. Add one with: olam repos add --name <n> --path <p>"));
       return;
     }
     printHeader(`${all.length} repo(s)`);
     for (const r of all) {
       const when = new Date(r.addedAt).toISOString().slice(0, 10);
       console.log(
-        `  ${pc24.bold(r.name.padEnd(24))} ${r.path.padEnd(48)} ${pc24.dim(when)}`
+        `  ${pc25.bold(r.name.padEnd(24))} ${r.path.padEnd(48)} ${pc25.dim(when)}`
       );
     }
   });
@@ -24980,7 +25350,7 @@ function registerRepos(program2) {
 }
 
 // src/commands/runbooks.ts
-import pc25 from "picocolors";
+import pc26 from "picocolors";
 init_output();
 function asMessage2(err) {
   return err instanceof Error ? err.message : String(err);
@@ -25011,14 +25381,14 @@ function parsePortFlags(ports) {
 }
 function formatConflict(c) {
   const occupantStr = c.occupant.type === "olam-world" ? `in use by world "${c.occupant.worldId}" (olam)` : `in use by PID ${c.occupant.pid ?? "unknown"} (non-olam process)`;
-  return `  ${pc25.red("\u2717")} ${c.repoName}.${c.serviceName}:${c.port} \u2014 ${occupantStr}`;
+  return `  ${pc26.red("\u2717")} ${c.repoName}.${c.serviceName}:${c.port} \u2014 ${occupantStr}`;
 }
 function registerRunbooks(program2) {
   const runbooks = program2.command("runbooks").description("Manage runbooks in the global config");
   runbooks.command("list").description("List all runbooks").action(() => {
     const all = listRunbooks();
     if (all.length === 0) {
-      console.log(pc25.dim("0 runbook(s). Add one with: olam runbooks add <name> --repos <repo>"));
+      console.log(pc26.dim("0 runbook(s). Add one with: olam runbooks add <name> --repos <repo>"));
       return;
     }
     printHeader(`${all.length} runbook(s)`);
@@ -25026,7 +25396,7 @@ function registerRunbooks(program2) {
       const when = new Date(rb.updatedAt).toISOString().slice(0, 10);
       const repoList = rb.repos.join(", ");
       console.log(
-        `  ${pc25.bold(rb.name.padEnd(24))} ${repoList.padEnd(40)} ${pc25.dim(when)}`
+        `  ${pc26.bold(rb.name.padEnd(24))} ${repoList.padEnd(40)} ${pc26.dim(when)}`
       );
     }
   });
@@ -25082,17 +25452,17 @@ ${conflicts.length} port conflict(s). Stop the conflicting processes or update p
         return;
       }
       console.log(
-        pc25.dim(
+        pc26.dim(
           `olam runbooks apply: port validation passed for "${name}" (repos: ${rb.repos.join(", ")}).`
         )
       );
       console.log(
-        pc25.dim(
+        pc26.dim(
           `Hint: use "olam create --repos ${rb.repos.join(" ")}${opts.task ? ` --task "${opts.task}"` : ""}${opts.name ? ` --name ${opts.name}` : ""}" to create the world.`
         )
       );
       console.log(
-        pc25.yellow('Phase D will wire --runbook directly. For now, use "olam create --repos ..." above.')
+        pc26.yellow('Phase D will wire --runbook directly. For now, use "olam create --repos ..." above.')
       );
     } catch (err) {
       printError(asMessage2(err));
@@ -25104,7 +25474,7 @@ ${conflicts.length} port conflict(s). Stop the conflicting processes or update p
       const rb = getRunbook(name);
       const { conflicts } = validateRunbookPorts(rb);
       if (!rb.portMap || Object.keys(rb.portMap).length === 0) {
-        console.log(pc25.dim(`runbook "${name}" declares no ports.`));
+        console.log(pc26.dim(`runbook "${name}" declares no ports.`));
         return;
       }
       for (const [repoName, svcMap] of Object.entries(rb.portMap ?? {})) {
@@ -25113,7 +25483,7 @@ ${conflicts.length} port conflict(s). Stop the conflicting processes or update p
           if (conflict) {
             console.log(formatConflict(conflict));
           } else {
-            console.log(`  ${pc25.green("\u2713")} ${repoName}.${svcName}:${port} \u2014 free`);
+            console.log(`  ${pc26.green("\u2713")} ${repoName}.${svcName}:${port} \u2014 free`);
           }
         }
       }
@@ -25124,7 +25494,7 @@ ${conflicts.length} port conflict(s). Stop the conflicting processes or update p
         );
         process.exitCode = 1;
       } else {
-        console.log(pc25.green("\n\u2713 all ports free"));
+        console.log(pc26.green("\n\u2713 all ports free"));
       }
     } catch (err) {
       printError(asMessage2(err));
@@ -25214,8 +25584,8 @@ var SECRET = process.env["OLAM_MCP_AUTH_SECRET"] ?? "";
 function authHeaders() {
   return SECRET ? { "X-Olam-Mcp-Secret": SECRET } : {};
 }
-async function apiFetch(path48, init = {}) {
-  const res = await fetch(`${BASE_URL}${path48}`, {
+async function apiFetch(path49, init = {}) {
+  const res = await fetch(`${BASE_URL}${path49}`, {
     ...init,
     headers: {
       "Content-Type": "application/json",
@@ -25367,7 +25737,7 @@ function registerMcpAdd(cmd) {
 
 // src/commands/mcp/list.ts
 init_output();
-import pc26 from "picocolors";
+import pc27 from "picocolors";
 function registerMcpList(cmd) {
   cmd.command("list").description("List all registered MCP credentials").action(async () => {
     const client = getMcpAuthClient();
@@ -25382,8 +25752,8 @@ function registerMcpList(cmd) {
     }
     const mcps = data.mcps ?? [];
     if (mcps.length === 0) {
-      console.log(pc26.dim("No MCP credentials registered."));
-      console.log(pc26.dim("Add one with: olam mcp add <service>"));
+      console.log(pc27.dim("No MCP credentials registered."));
+      console.log(pc27.dim("Add one with: olam mcp add <service>"));
       return;
     }
     const [c0, c1, c2, c3] = [16, 20, 10, 24];
@@ -25394,12 +25764,12 @@ function registerMcpList(cmd) {
       "ENV VAR".padEnd(c3),
       "STATUS"
     ].join("  ");
-    console.log(pc26.dim(header));
-    console.log(pc26.dim("\u2500".repeat(header.length)));
+    console.log(pc27.dim(header));
+    console.log(pc27.dim("\u2500".repeat(header.length)));
     for (const m of mcps) {
-      const status = !m.validated ? pc26.yellow("unvalidated") : m.expired ? pc26.red("expired") : pc26.green("active");
+      const status = !m.validated ? pc27.yellow("unvalidated") : m.expired ? pc27.red("expired") : pc27.green("active");
       const row = [
-        pc26.cyan(m.service.padEnd(c0)),
+        pc27.cyan(m.service.padEnd(c0)),
         m.label.padEnd(c1).slice(0, c1),
         m.type.padEnd(c2),
         (m.envName ?? "\u2014").padEnd(c3).slice(0, c3),
@@ -25427,13 +25797,13 @@ function registerMcpRemove(cmd) {
 
 // src/commands/mcp/status.ts
 init_output();
-import pc27 from "picocolors";
+import pc28 from "picocolors";
 function formatExpiry(expiresAt) {
   if (!expiresAt) return "\u2014";
   const ms = expiresAt - Date.now();
-  if (ms <= 0) return pc27.red("expired");
+  if (ms <= 0) return pc28.red("expired");
   const hours = ms / (1e3 * 60 * 60);
-  if (hours < 1) return pc27.yellow(`${Math.ceil(ms / 6e4)}m`);
+  if (hours < 1) return pc28.yellow(`${Math.ceil(ms / 6e4)}m`);
   return `${hours.toFixed(1)}h`;
 }
 function registerMcpStatus(cmd) {
@@ -25450,14 +25820,14 @@ function registerMcpStatus(cmd) {
     const mcps = data.mcps ?? [];
     printHeader(`MCP Credentials (${mcps.length})`);
     if (mcps.length === 0) {
-      console.log(pc27.dim("No credentials registered."));
+      console.log(pc28.dim("No credentials registered."));
       return;
     }
     for (const m of mcps) {
-      const stateColor = !m.validated ? pc27.yellow : m.expired ? pc27.red : pc27.green;
+      const stateColor = !m.validated ? pc28.yellow : m.expired ? pc28.red : pc28.green;
       const stateLabel = !m.validated ? "unvalidated" : m.expired ? "expired" : "active";
       console.log(`
-  ${pc27.cyan(m.service)} ${stateColor(`[${stateLabel}]`)}`);
+  ${pc28.cyan(m.service)} ${stateColor(`[${stateLabel}]`)}`);
       console.log(`    label:      ${m.label}`);
       console.log(`    type:       ${m.type}`);
       if (m.envName) console.log(`    env var:    ${m.envName}`);
@@ -25472,15 +25842,15 @@ function registerMcpStatus(cmd) {
 // src/commands/mcp/import.ts
 init_output();
 import * as readline3 from "node:readline";
-import pc28 from "picocolors";
+import pc29 from "picocolors";
 
 // src/commands/mcp/import-discovery.ts
-import * as fs44 from "node:fs";
-import * as os26 from "node:os";
-import * as path46 from "node:path";
+import * as fs45 from "node:fs";
+import * as os27 from "node:os";
+import * as path47 from "node:path";
 function readJsonFile(filePath) {
   try {
-    const raw = fs44.readFileSync(filePath, "utf-8");
+    const raw = fs45.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -25509,24 +25879,24 @@ function extractMcpServers(obj, source, sourceLabel) {
 }
 function getClaudeDesktopPath() {
   if (process.platform === "darwin") {
-    return path46.join(os26.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    return path47.join(os27.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
   }
   if (process.platform === "win32") {
-    const appData = process.env["APPDATA"] ?? path46.join(os26.homedir(), "AppData", "Roaming");
-    return path46.join(appData, "Claude", "claude_desktop_config.json");
+    const appData = process.env["APPDATA"] ?? path47.join(os27.homedir(), "AppData", "Roaming");
+    return path47.join(appData, "Claude", "claude_desktop_config.json");
   }
-  return path46.join(os26.homedir(), ".config", "Claude", "claude_desktop_config.json");
+  return path47.join(os27.homedir(), ".config", "Claude", "claude_desktop_config.json");
 }
 function getOlamRepoPaths() {
   const configPaths = [
-    path46.join(os26.homedir(), ".olam", "config.yaml"),
-    path46.join(process.cwd(), ".olam", "config.yaml")
+    path47.join(os27.homedir(), ".olam", "config.yaml"),
+    path47.join(process.cwd(), ".olam", "config.yaml")
   ];
   const paths = [];
   for (const configPath of configPaths) {
-    if (!fs44.existsSync(configPath)) continue;
+    if (!fs45.existsSync(configPath)) continue;
     try {
-      const raw = fs44.readFileSync(configPath, "utf-8");
+      const raw = fs45.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]);
@@ -25542,7 +25912,7 @@ async function discoverMcpSources(repoPaths) {
   const sources = [];
   const sourceDefs = [
     {
-      path: path46.join(os26.homedir(), ".claude.json"),
+      path: path47.join(os27.homedir(), ".claude.json"),
       label: "Claude Code (~/.claude.json)"
     },
     {
@@ -25550,19 +25920,19 @@ async function discoverMcpSources(repoPaths) {
       label: "Claude Desktop"
     },
     {
-      path: path46.join(os26.homedir(), ".cursor", "mcp.json"),
+      path: path47.join(os27.homedir(), ".cursor", "mcp.json"),
       label: "Cursor (~/.cursor/mcp.json)"
     },
     {
-      path: path46.join(os26.homedir(), ".codeium", "windsurf", "mcp_config.json"),
+      path: path47.join(os27.homedir(), ".codeium", "windsurf", "mcp_config.json"),
       label: "Windsurf (~/.codeium/windsurf/mcp_config.json)"
     }
   ];
   const resolvedRepoPaths = repoPaths ?? getOlamRepoPaths();
   for (const repoPath of resolvedRepoPaths) {
     sourceDefs.push({
-      path: path46.join(repoPath, ".mcp.json"),
-      label: `.mcp.json (${path46.basename(repoPath)})`
+      path: path47.join(repoPath, ".mcp.json"),
+      label: `.mcp.json (${path47.basename(repoPath)})`
     });
   }
   const reads = await Promise.all(
@@ -25642,13 +26012,13 @@ async function validateMcpEntry(entry) {
 // src/commands/mcp/import.ts
 async function multiSelectPicker(entries) {
   if (entries.length === 0) return [];
-  console.log("\n" + pc28.bold("Discovered MCP servers:"));
+  console.log("\n" + pc29.bold("Discovered MCP servers:"));
   entries.forEach((e, i) => {
     console.log(
-      `  ${pc28.dim(`[${i + 1}]`)} ${pc28.cyan(e.name.padEnd(20))} ${pc28.dim(e.sourceLabel)}`
+      `  ${pc29.dim(`[${i + 1}]`)} ${pc29.cyan(e.name.padEnd(20))} ${pc29.dim(e.sourceLabel)}`
     );
   });
-  console.log("\n" + pc28.dim('Enter numbers to import (e.g. 1,2,3 or "all" or Enter to skip):'));
+  console.log("\n" + pc29.dim('Enter numbers to import (e.g. 1,2,3 or "all" or Enter to skip):'));
   const answer = await new Promise((resolve10) => {
     const rl = readline3.createInterface({ input: process.stdin, output: process.stdout });
     rl.question("> ", (ans) => {
@@ -25675,7 +26045,7 @@ function registerMcpImport(cmd) {
     const repoPaths = opts.repoPaths ? opts.repoPaths.split(",").map((s) => s.trim()) : void 0;
     const { entries, sources, durationMs } = await discoverMcpSources(repoPaths);
     if (entries.length === 0) {
-      console.log(pc28.dim("No MCP servers found in any source path."));
+      console.log(pc29.dim("No MCP servers found in any source path."));
       return;
     }
     printInfo("Sources", sources.length > 0 ? sources.join(", ") : "none");
@@ -25688,15 +26058,15 @@ function registerMcpImport(cmd) {
       candidates = filtered;
     }
     if (skippedCount > 0) {
-      console.log(pc28.dim(`skipped: ${skippedCount} already registered`));
+      console.log(pc29.dim(`skipped: ${skippedCount} already registered`));
     }
     if (candidates.length === 0) {
-      console.log(pc28.dim("Nothing new to import. Use --reimport to force."));
+      console.log(pc29.dim("Nothing new to import. Use --reimport to force."));
       return;
     }
     const selected = await multiSelectPicker(candidates);
     if (selected.length === 0) {
-      console.log(pc28.dim("No servers selected."));
+      console.log(pc29.dim("No servers selected."));
       return;
     }
     console.log(`
@@ -25707,16 +26077,16 @@ Importing ${selected.length} server(s)\u2026`);
       let validated = false;
       let validationReason = "skipped";
       if (opts.validate !== false) {
-        process.stdout.write(`  ${pc28.dim("\u2192")} ${entry.name}  validating\u2026 `);
+        process.stdout.write(`  ${pc29.dim("\u2192")} ${entry.name}  validating\u2026 `);
         const vr = await validateMcpEntry(entry);
         validated = vr.validated;
         validationReason = vr.reason;
         process.stdout.write(
-          validated ? pc28.green("ok\n") : pc28.yellow(`unvalidated (${vr.reason})
+          validated ? pc29.green("ok\n") : pc29.yellow(`unvalidated (${vr.reason})
 `)
         );
       } else {
-        console.log(`  ${pc28.dim("\u2192")} ${entry.name}  ${pc28.dim("(validation skipped)")}`);
+        console.log(`  ${pc29.dim("\u2192")} ${entry.name}  ${pc29.dim("(validation skipped)")}`);
       }
       if (validated) validatedCount++;
       const result = await client.staticAdd({
@@ -25731,21 +26101,21 @@ Importing ${selected.length} server(s)\u2026`);
       }
     }
     console.log("");
-    console.log(pc28.green(`\u2713 Imported ${importedCount}/${selected.length}`));
+    console.log(pc29.green(`\u2713 Imported ${importedCount}/${selected.length}`));
     if (validatedCount > 0) {
-      console.log(pc28.dim(`  ${validatedCount} validated, ${importedCount - validatedCount} unvalidated`));
+      console.log(pc29.dim(`  ${validatedCount} validated, ${importedCount - validatedCount} unvalidated`));
     }
   });
 }
 
 // src/commands/mcp/revoke.ts
 init_output();
-import pc29 from "picocolors";
+import pc30 from "picocolors";
 function registerMcpRevoke(cmd) {
   cmd.command("revoke <user> <world> <service>").description("Revoke a user's MCP service entitlement (multi-tenant mode only)").action(async (user, world, service) => {
     const multiTenant = (process.env["OLAM_MCP_MULTI_TENANT"] ?? "").toLowerCase() === "true";
     if (!multiTenant) {
-      console.warn(pc29.yellow("\u26A0 revocation only meaningful in multi_tenant mode \u2014 no-op"));
+      console.warn(pc30.yellow("\u26A0 revocation only meaningful in multi_tenant mode \u2014 no-op"));
       return;
     }
     const baseUrl = process.env["OLAM_MCP_AUTH_SERVICE_URL"] ?? "http://127.0.0.1:9998";
@@ -25774,8 +26144,8 @@ function registerMcpRevoke(cmd) {
       process.exitCode = 1;
       return;
     }
-    console.log(pc29.green(`\u2713 Revoked: ${user} / ${world} / ${service}`));
-    console.log(pc29.dim("  Next fetch-creds call returns 403; token cleared on next merge."));
+    console.log(pc30.green(`\u2713 Revoked: ${user} / ${world} / ${service}`));
+    console.log(pc30.dim("  Next fetch-creds call returns 403; token cleared on next merge."));
   });
 }
 
@@ -25792,18 +26162,18 @@ function registerMcp(program2) {
 }
 
 // src/pleri-config.ts
-import * as fs45 from "node:fs";
-import * as path47 from "node:path";
+import * as fs46 from "node:fs";
+import * as path48 from "node:path";
 function isPleriConfigured(configDir = process.env.OLAM_CONFIG_DIR ?? ".olam") {
   if (process.env.PLERI_BASE_URL) {
     return true;
   }
-  const configPath = path47.join(configDir, "config.yaml");
-  if (!fs45.existsSync(configPath)) {
+  const configPath = path48.join(configDir, "config.yaml");
+  if (!fs46.existsSync(configPath)) {
     return false;
   }
   try {
-    const contents = fs45.readFileSync(configPath, "utf8");
+    const contents = fs46.readFileSync(configPath, "utf8");
     return /^[^#\n]*\bpleri:/m.test(contents);
   } catch {
     return false;
@@ -25823,6 +26193,7 @@ registerList(program);
 registerStatus(program);
 registerDestroy(program);
 registerClean(program);
+registerImplode(program);
 registerEnter(program);
 registerCrystallize(program, { hidden: !isPleriConfigured() });
 registerPr(program);