@pleri/olam-cli 0.1.69 → 0.1.70

package/dist/index.js

@@ -15,6 +15,33 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/cli-version.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+function readCliVersion() {
+  try {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    for (const candidate of [
+      path.join(here, "package.json"),
+      path.join(here, "..", "package.json"),
+      path.join(here, "..", "..", "package.json")
+    ]) {
+      if (fs.existsSync(candidate)) {
+        const pkg = JSON.parse(fs.readFileSync(candidate, "utf-8"));
+        if (typeof pkg.version === "string" && pkg.version.length > 0) return pkg.version;
+      }
+    }
+  } catch {
+  }
+  return "0.0.0-unknown";
+}
+var init_cli_version = __esm({
+  "src/cli-version.ts"() {
+    "use strict";
+  }
+});
+
 // src/output.ts
 import pc from "picocolors";
 function printError(message) {
@@ -4248,8 +4275,8 @@ var init_version2 = __esm({
 });
 
 // ../core/dist/world/repo-manifest.js
-import { existsSync, lstatSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync as existsSync2, lstatSync, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
 import YAML from "yaml";
 function bootstrapStepCmd(entry) {
   return typeof entry === "string" ? entry : entry.cmd;
@@ -4296,14 +4323,14 @@ function unknownTopLevelKeys(parsed) {
   return Object.keys(parsed).filter((k) => !KNOWN_TOP_LEVEL_KEYS.has(k));
 }
 function loadRepoManifest(repoDir) {
-  const olamPath = join(repoDir, ".olam.yaml");
-  const adbPath = join(repoDir, ".adb.yaml");
+  const olamPath = join2(repoDir, ".olam.yaml");
+  const adbPath = join2(repoDir, ".adb.yaml");
   let manifestPath2;
   let source;
-  if (existsSync(olamPath)) {
+  if (existsSync2(olamPath)) {
     manifestPath2 = olamPath;
     source = "olam";
-  } else if (existsSync(adbPath)) {
+  } else if (existsSync2(adbPath)) {
     manifestPath2 = adbPath;
     source = "adb";
   } else {
@@ -4313,10 +4340,10 @@ function loadRepoManifest(repoDir) {
   if (stat.isSymbolicLink()) {
     throw new Error(`[manifest] ${manifestPath2}: symbolic links are not permitted`);
   }
-  const raw = readFileSync(manifestPath2, "utf-8");
+  const raw = readFileSync2(manifestPath2, "utf-8");
   const parsed = YAML.parse(raw, { maxAliasCount: 100 });
   if (parsed === null || parsed === void 0) {
-    if (source === "olam" && existsSync(adbPath)) {
+    if (source === "olam" && existsSync2(adbPath)) {
       console.warn(`[manifest] ${manifestPath2}: file is empty; .adb.yaml is NOT consulted (delete .olam.yaml to fall back)`);
     }
     return null;
@@ -4421,12 +4448,12 @@ var init_repo_manifest = __esm({
 
 // ../core/dist/util/path.js
 import * as os from "node:os";
-import * as path from "node:path";
+import * as path2 from "node:path";
 function resolveTildePath(p) {
   if (p === "~")
     return os.homedir();
   if (p.startsWith("~/"))
-    return path.join(os.homedir(), p.slice(2));
+    return path2.join(os.homedir(), p.slice(2));
   if (p.startsWith("~")) {
     throw new Error(`[path] POSIX "~user" syntax is not supported (got "${p}"). Use "~/..." for the operator's home or an absolute path.`);
   }
@@ -4441,15 +4468,15 @@ var init_path = __esm({
 });
 
 // ../core/dist/workspace/store.js
-import * as fs from "node:fs";
+import * as fs2 from "node:fs";
 import * as os2 from "node:os";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
 function workspacesDir() {
   const override = process.env["OLAM_WORKSPACES_DIR"];
   if (override && override.length > 0)
     return override;
-  return path2.join(os2.homedir(), ".olam", "workspaces");
+  return path3.join(os2.homedir(), ".olam", "workspaces");
 }
 function validateName(name) {
   if (!WORKSPACE_NAME_PATTERN.test(name)) {
@@ -4457,17 +4484,17 @@ function validateName(name) {
   }
 }
 function filePathFor(name) {
-  return path2.join(workspacesDir(), `${name}.yaml`);
+  return path3.join(workspacesDir(), `${name}.yaml`);
 }
 function listWorkspaces() {
   const dir = workspacesDir();
-  if (!fs.existsSync(dir))
+  if (!fs2.existsSync(dir))
     return [];
-  const entries = fs.readdirSync(dir).filter((f) => f.endsWith(".yaml"));
+  const entries = fs2.readdirSync(dir).filter((f) => f.endsWith(".yaml"));
   const result = [];
   for (const entry of entries) {
     try {
-      const raw = fs.readFileSync(path2.join(dir, entry), "utf-8");
+      const raw = fs2.readFileSync(path3.join(dir, entry), "utf-8");
       const parsed = parseYaml(raw);
       const ws = WorkspaceSchema.parse(parsed);
       result.push(ws);
@@ -4483,30 +4510,30 @@ function listWorkspaces() {
 function readWorkspace(name) {
   validateName(name);
   const file = filePathFor(name);
-  if (!fs.existsSync(file))
+  if (!fs2.existsSync(file))
     return null;
-  const raw = fs.readFileSync(file, "utf-8");
+  const raw = fs2.readFileSync(file, "utf-8");
   return WorkspaceSchema.parse(parseYaml(raw));
 }
 function writeWorkspace(ws, options = {}) {
   validateName(ws.name);
   const parsed = WorkspaceSchema.parse(ws);
   const dir = workspacesDir();
-  fs.mkdirSync(dir, { recursive: true });
+  fs2.mkdirSync(dir, { recursive: true });
   const final = filePathFor(parsed.name);
-  if (fs.existsSync(final) && options.force !== true) {
+  if (fs2.existsSync(final) && options.force !== true) {
     throw new WorkspaceExistsError(parsed.name);
   }
   const tmp = `${final}.tmp-${process.pid}`;
-  fs.writeFileSync(tmp, stringifyYaml(parsed), { mode: 420 });
-  fs.renameSync(tmp, final);
+  fs2.writeFileSync(tmp, stringifyYaml(parsed), { mode: 420 });
+  fs2.renameSync(tmp, final);
 }
 function removeWorkspace(name) {
   validateName(name);
   const file = filePathFor(name);
-  if (!fs.existsSync(file))
+  if (!fs2.existsSync(file))
     return false;
-  fs.unlinkSync(file);
+  fs2.unlinkSync(file);
   return true;
 }
 function workspaceToRepoConfigs(ws) {
@@ -4996,11 +5023,11 @@ var init_substitute = __esm({
 });
 
 // ../core/dist/config/dotenv.js
-import * as fs2 from "node:fs";
+import * as fs3 from "node:fs";
 function loadDotEnv(envPath) {
-  if (!fs2.existsSync(envPath))
+  if (!fs3.existsSync(envPath))
     return;
-  const content = fs2.readFileSync(envPath, "utf-8");
+  const content = fs3.readFileSync(envPath, "utf-8");
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#"))
@@ -5026,23 +5053,23 @@ var loader_exports = {};
 __export(loader_exports, {
   loadConfig: () => loadConfig
 });
-import * as fs3 from "node:fs";
-import * as path3 from "node:path";
+import * as fs4 from "node:fs";
+import * as path4 from "node:path";
 import { parse as parseYaml2 } from "yaml";
 function findConfigFile(startDir) {
   const searched = [];
-  let current = path3.resolve(startDir);
+  let current = path4.resolve(startDir);
   while (true) {
-    const newLayout = path3.join(current, CONFIG_DIR_NAME, CONFIG_FILENAME);
-    const legacyLayout = path3.join(current, LEGACY_CONFIG_FILENAME);
+    const newLayout = path4.join(current, CONFIG_DIR_NAME, CONFIG_FILENAME);
+    const legacyLayout = path4.join(current, LEGACY_CONFIG_FILENAME);
     searched.push(newLayout, legacyLayout);
-    if (fs3.existsSync(newLayout)) {
+    if (fs4.existsSync(newLayout)) {
       return { path: newLayout, isLegacy: false };
     }
-    if (fs3.existsSync(legacyLayout)) {
+    if (fs4.existsSync(legacyLayout)) {
       return { path: legacyLayout, isLegacy: true };
     }
-    const parent = path3.dirname(current);
+    const parent = path4.dirname(current);
     if (parent === current)
       break;
     current = parent;
@@ -5057,12 +5084,12 @@ function loadConfig(startDir) {
        Run /olam:init to migrate to .olam/config.yaml
 `);
   } else {
-    const envPath = path3.join(path3.dirname(found.path), ".env");
+    const envPath = path4.join(path4.dirname(found.path), ".env");
     loadDotEnv(envPath);
   }
   let rawContent;
   try {
-    rawContent = fs3.readFileSync(found.path, "utf-8");
+    rawContent = fs4.readFileSync(found.path, "utf-8");
   } catch (err) {
     throw new Error(`Failed to read ${found.path}: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -5104,27 +5131,27 @@ var init_loader = __esm({
 
 // ../core/dist/auth/secret.js
 import * as crypto from "node:crypto";
-import * as fs7 from "node:fs";
+import * as fs8 from "node:fs";
 import * as os4 from "node:os";
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 function getSecretFilePath() {
-  return path7.join(os4.homedir(), ".olam", SECRET_FILENAME);
+  return path8.join(os4.homedir(), ".olam", SECRET_FILENAME);
 }
 function getOrCreateSecret() {
   const fromEnv = process.env[SECRET_ENV_VAR];
   if (fromEnv && fromEnv.length > 0)
     return fromEnv;
   const file = getSecretFilePath();
-  if (fs7.existsSync(file)) {
-    const value = fs7.readFileSync(file, "utf-8").trim();
+  if (fs8.existsSync(file)) {
+    const value = fs8.readFileSync(file, "utf-8").trim();
     if (value.length > 0)
       return value;
   }
   const generated = crypto.randomBytes(SECRET_BYTES).toString("base64url");
-  fs7.mkdirSync(path7.dirname(file), { recursive: true });
-  fs7.writeFileSync(file, generated, { mode: 384 });
+  fs8.mkdirSync(path8.dirname(file), { recursive: true });
+  fs8.writeFileSync(file, generated, { mode: 384 });
   try {
-    fs7.chmodSync(file, 384);
+    fs8.chmodSync(file, 384);
   } catch {
   }
   return generated;
@@ -5134,9 +5161,9 @@ function readSecretIfExists() {
   if (fromEnv && fromEnv.length > 0)
     return fromEnv;
   const file = getSecretFilePath();
-  if (!fs7.existsSync(file))
+  if (!fs8.existsSync(file))
     return null;
-  const value = fs7.readFileSync(file, "utf-8").trim();
+  const value = fs8.readFileSync(file, "utf-8").trim();
   return value.length > 0 ? value : null;
 }
 var SECRET_ENV_VAR, SECRET_FILENAME, SECRET_BYTES;
@@ -5312,13 +5339,13 @@ var init_client = __esm({
 
 // ../core/dist/auth/container.js
 import { execFileSync, spawnSync } from "node:child_process";
-import { existsSync as existsSync8 } from "node:fs";
-import * as path8 from "node:path";
-import { fileURLToPath } from "node:url";
+import { existsSync as existsSync9 } from "node:fs";
+import * as path9 from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 function resolveAuthServicePath() {
-  const here = fileURLToPath(import.meta.url);
-  const pkgsDir = path8.resolve(path8.dirname(here), "..", "..", "..");
-  return path8.join(pkgsDir, "auth-service");
+  const here = fileURLToPath2(import.meta.url);
+  const pkgsDir = path9.resolve(path9.dirname(here), "..", "..", "..");
+  return path9.join(pkgsDir, "auth-service");
 }
 function sleep2(ms) {
   return new Promise((resolve8) => setTimeout(resolve8, ms));
@@ -5394,7 +5421,7 @@ var init_container = __esm({
        */
       buildImage() {
         const dockerfileDir = resolveAuthServicePath();
-        if (!existsSync8(path8.join(dockerfileDir, "Dockerfile"))) {
+        if (!existsSync9(path9.join(dockerfileDir, "Dockerfile"))) {
           throw new Error(`auth image '${this.imageTag}' is not present locally and no Dockerfile is available at ${dockerfileDir} to build from. Run \`olam bootstrap\` to pull the published image, or check out the olam source tree.`);
         }
         execFileSync("docker", ["build", "--tag", this.imageTag, dockerfileDir], { stdio: "inherit" });
@@ -5627,16 +5654,16 @@ var init_volume = __esm({
 });
 
 // ../adapters/dist/docker/container.js
-import * as fs9 from "node:fs";
+import * as fs10 from "node:fs";
 import * as os6 from "node:os";
-import * as path10 from "node:path";
+import * as path11 from "node:path";
 function readAuthSecret() {
   const fromEnv = process.env["OLAM_AUTH_SECRET"];
   if (fromEnv && fromEnv.length > 0)
     return fromEnv;
-  const file = path10.join(os6.homedir(), ".olam", "auth-secret");
+  const file = path11.join(os6.homedir(), ".olam", "auth-secret");
   try {
-    return fs9.readFileSync(file, "utf-8").trim();
+    return fs10.readFileSync(file, "utf-8").trim();
   } catch {
     return "";
   }
@@ -5645,9 +5672,9 @@ function readHostCpToken() {
   const fromEnv = process.env["OLAM_HOST_CP_TOKEN"];
   if (fromEnv && fromEnv.length > 0)
     return fromEnv;
-  const file = path10.join(os6.homedir(), ".olam", "host-cp.token");
+  const file = path11.join(os6.homedir(), ".olam", "host-cp.token");
   try {
-    return fs9.readFileSync(file, "utf-8").trim();
+    return fs10.readFileSync(file, "utf-8").trim();
   } catch {
     return "";
   }
@@ -5658,11 +5685,11 @@ function sanitizeContainerName(name) {
 function buildPackageManagerCacheBinds(homeDir) {
   const result = [];
   for (const entry of PACKAGE_MANAGER_CACHE_DIRS) {
-    const hostPath = path10.join(homeDir, entry.hostSubpath);
+    const hostPath = path11.join(homeDir, entry.hostSubpath);
     try {
-      fs9.mkdirSync(hostPath, { recursive: true, mode: 448 });
+      fs10.mkdirSync(hostPath, { recursive: true, mode: 448 });
       try {
-        fs9.chmodSync(hostPath, 448);
+        fs10.chmodSync(hostPath, 448);
       } catch {
       }
       result.push(`${hostPath}:${entry.containerPath}:rw`);
@@ -5814,12 +5841,12 @@ var init_container2 = __esm({
       if (workspacePath) {
         binds.push(`${workspacePath}:/home/olam/workspace:rw`);
       }
-      const r2CredHostPath = path10.join(olamHomeDir, ".olam", "r2-credentials.json");
-      if (fs9.existsSync(r2CredHostPath)) {
+      const r2CredHostPath = path11.join(olamHomeDir, ".olam", "r2-credentials.json");
+      if (fs10.existsSync(r2CredHostPath)) {
         binds.push(`${r2CredHostPath}:/etc/olam/r2-credentials.json:ro`);
       }
-      const gcloudCredsDir = path10.join(olamHomeDir, ".config", "gcloud");
-      if (fs9.existsSync(gcloudCredsDir)) {
+      const gcloudCredsDir = path11.join(olamHomeDir, ".config", "gcloud");
+      if (fs10.existsSync(gcloudCredsDir)) {
         binds.push(`${gcloudCredsDir}:/home/olam/.config/gcloud:ro`);
       }
       const hostControlPlanePort = HOST_CONTROL_PLANE_BASE + (portOffset ?? 0);
@@ -6254,7 +6281,7 @@ var init_cleanup = __esm({
 
 // ../adapters/dist/ssh/connection.js
 import { Client as SSHClient } from "ssh2";
-import { readFileSync as readFileSync9 } from "node:fs";
+import { readFileSync as readFileSync10 } from "node:fs";
 var SSHConnectionPool;
 var init_connection = __esm({
   "../adapters/dist/ssh/connection.js"() {
@@ -6349,7 +6376,7 @@ var init_connection = __esm({
             host: config.host,
             port: config.port ?? 22,
             username: config.user,
-            ...config.key ? { privateKey: readFileSync9(config.key) } : {},
+            ...config.key ? { privateKey: readFileSync10(config.key) } : {},
             ...config.password ? { password: config.password } : {}
           });
         });
@@ -7058,8 +7085,8 @@ __export(registry_exports, {
 import { createRequire } from "node:module";
 import * as net from "node:net";
 import * as os7 from "node:os";
-import * as path11 from "node:path";
-import * as fs10 from "node:fs";
+import * as path12 from "node:path";
+import * as fs11 from "node:fs";
 function getDatabase() {
   if (_Database === null) {
     _Database = _require("better-sqlite3");
@@ -7165,9 +7192,9 @@ CREATE TABLE IF NOT EXISTS meta (
     WorldRegistry = class {
       db;
       constructor(dbPath) {
-        const resolvedPath = dbPath ?? path11.join(os7.homedir(), ".olam", "worlds.db");
+        const resolvedPath = dbPath ?? path12.join(os7.homedir(), ".olam", "worlds.db");
         if (resolvedPath !== ":memory:") {
-          fs10.mkdirSync(path11.dirname(resolvedPath), { recursive: true });
+          fs11.mkdirSync(path12.dirname(resolvedPath), { recursive: true });
         }
         const Database = getDatabase();
         this.db = new Database(resolvedPath);
@@ -7354,8 +7381,8 @@ var init_devbox_image = __esm({
 
 // ../core/dist/world/worktree.js
 import { execFileSync as execFileSync2 } from "node:child_process";
-import * as fs11 from "node:fs";
-import * as path12 from "node:path";
+import * as fs12 from "node:fs";
+import * as path13 from "node:path";
 function resolveGitDir(repo) {
   if (repo.path) {
     return repo.path;
@@ -7365,11 +7392,11 @@ function resolveGitDir(repo) {
 async function createWorktrees(repos, worldId, workspacePath, branch) {
   const created = [];
   for (const repo of repos) {
-    const worktreePath = path12.join(workspacePath, repo.name);
+    const worktreePath = path13.join(workspacePath, repo.name);
     const gitDir = resolveGitDir(repo);
     const branchName = branch || `olam/${worldId}`;
     try {
-      fs11.mkdirSync(path12.dirname(worktreePath), { recursive: true });
+      fs12.mkdirSync(path13.dirname(worktreePath), { recursive: true });
       execFileSync2("git", ["worktree", "add", worktreePath, "-b", branchName], {
         cwd: gitDir,
         stdio: "pipe"
@@ -7402,7 +7429,7 @@ async function createWorktrees(repos, worldId, workspacePath, branch) {
 }
 async function removeWorktrees(repos, workspacePath) {
   for (const repo of repos) {
-    const worktreePath = path12.join(workspacePath, repo.name);
+    const worktreePath = path13.join(workspacePath, repo.name);
     let gitDir;
     try {
       gitDir = resolveGitDir(repo);
@@ -7571,85 +7598,85 @@ var init_hooks_config = __esm({
 
 // ../core/dist/world/env-setup.js
 import * as crypto2 from "node:crypto";
-import * as fs12 from "node:fs";
+import * as fs13 from "node:fs";
 import * as os8 from "node:os";
-import * as path13 from "node:path";
+import * as path14 from "node:path";
 import { globSync } from "node:fs";
 function copyClaudeConfig(workspacePath, homeDir, configCtx) {
-  const sourceClaudeDir = path13.join(homeDir ?? os8.homedir(), ".claude");
-  const destClaudeDir = path13.join(workspacePath, ".claude-host-config");
+  const sourceClaudeDir = path14.join(homeDir ?? os8.homedir(), ".claude");
+  const destClaudeDir = path14.join(workspacePath, ".claude-host-config");
   void configCtx;
-  if (!fs12.existsSync(sourceClaudeDir))
+  if (!fs13.existsSync(sourceClaudeDir))
     return;
-  fs12.mkdirSync(destClaudeDir, { recursive: true });
-  const settingsPath = path13.join(sourceClaudeDir, "settings.json");
+  fs13.mkdirSync(destClaudeDir, { recursive: true });
+  const settingsPath = path14.join(sourceClaudeDir, "settings.json");
   let settings = {};
-  if (fs12.existsSync(settingsPath)) {
+  if (fs13.existsSync(settingsPath)) {
     try {
-      settings = JSON.parse(fs12.readFileSync(settingsPath, "utf-8"));
+      settings = JSON.parse(fs13.readFileSync(settingsPath, "utf-8"));
       delete settings["hooks"];
     } catch {
     }
   }
   const hooksConfig = generateHooksConfig(DEFAULT_HOOK_SERVER_URL);
   settings["hooks"] = hooksConfig["hooks"];
-  fs12.writeFileSync(path13.join(destClaudeDir, "settings.json"), JSON.stringify(settings, null, 2));
-  const claudeMdPath = path13.join(sourceClaudeDir, "CLAUDE.md");
-  if (fs12.existsSync(claudeMdPath)) {
-    fs12.copyFileSync(claudeMdPath, path13.join(destClaudeDir, "CLAUDE.md"));
+  fs13.writeFileSync(path14.join(destClaudeDir, "settings.json"), JSON.stringify(settings, null, 2));
+  const claudeMdPath = path14.join(sourceClaudeDir, "CLAUDE.md");
+  if (fs13.existsSync(claudeMdPath)) {
+    fs13.copyFileSync(claudeMdPath, path14.join(destClaudeDir, "CLAUDE.md"));
   }
-  const rulesDir = path13.join(sourceClaudeDir, "rules");
-  if (fs12.existsSync(rulesDir)) {
-    copyDirRecursive(rulesDir, path13.join(destClaudeDir, "rules"));
+  const rulesDir = path14.join(sourceClaudeDir, "rules");
+  if (fs13.existsSync(rulesDir)) {
+    copyDirRecursive(rulesDir, path14.join(destClaudeDir, "rules"));
   }
-  const agentsDir = path13.join(sourceClaudeDir, "agents");
-  if (fs12.existsSync(agentsDir)) {
-    copyDirRecursive(agentsDir, path13.join(destClaudeDir, "agents"));
+  const agentsDir = path14.join(sourceClaudeDir, "agents");
+  if (fs13.existsSync(agentsDir)) {
+    copyDirRecursive(agentsDir, path14.join(destClaudeDir, "agents"));
   }
-  const pluginsDir = path13.join(sourceClaudeDir, "plugins");
-  if (fs12.existsSync(pluginsDir)) {
-    copyDirRecursive(pluginsDir, path13.join(destClaudeDir, "plugins"), 0, SKIP_FILES);
+  const pluginsDir = path14.join(sourceClaudeDir, "plugins");
+  if (fs13.existsSync(pluginsDir)) {
+    copyDirRecursive(pluginsDir, path14.join(destClaudeDir, "plugins"), 0, SKIP_FILES);
   }
-  const skillsDir = path13.join(sourceClaudeDir, "skills");
-  if (fs12.existsSync(skillsDir)) {
-    copyDirRecursive(skillsDir, path13.join(destClaudeDir, "skills"));
+  const skillsDir = path14.join(sourceClaudeDir, "skills");
+  if (fs13.existsSync(skillsDir)) {
+    copyDirRecursive(skillsDir, path14.join(destClaudeDir, "skills"));
   }
-  const scriptsDir = path13.join(sourceClaudeDir, "scripts");
-  if (fs12.existsSync(scriptsDir)) {
-    copyDirRecursive(scriptsDir, path13.join(destClaudeDir, "scripts"));
+  const scriptsDir = path14.join(sourceClaudeDir, "scripts");
+  if (fs13.existsSync(scriptsDir)) {
+    copyDirRecursive(scriptsDir, path14.join(destClaudeDir, "scripts"));
   }
   applyProjectClaudeOverlay(workspacePath, destClaudeDir);
   writeStrippedMcpServersSnapshot(homeDir ?? os8.homedir(), workspacePath, destClaudeDir);
 }
 function applyProjectClaudeOverlay(workspacePath, destClaudeDir) {
-  const projectClaudeDir = path13.join(workspacePath, ".claude");
-  if (!fs12.existsSync(projectClaudeDir))
+  const projectClaudeDir = path14.join(workspacePath, ".claude");
+  if (!fs13.existsSync(projectClaudeDir))
     return;
-  const projectSettingsPath = path13.join(projectClaudeDir, "settings.json");
-  const destSettingsPath = path13.join(destClaudeDir, "settings.json");
-  if (fs12.existsSync(projectSettingsPath)) {
+  const projectSettingsPath = path14.join(projectClaudeDir, "settings.json");
+  const destSettingsPath = path14.join(destClaudeDir, "settings.json");
+  if (fs13.existsSync(projectSettingsPath)) {
     try {
-      const projectSettings = JSON.parse(fs12.readFileSync(projectSettingsPath, "utf-8"));
+      const projectSettings = JSON.parse(fs13.readFileSync(projectSettingsPath, "utf-8"));
       delete projectSettings["hooks"];
-      const existing = fs12.existsSync(destSettingsPath) ? JSON.parse(fs12.readFileSync(destSettingsPath, "utf-8")) : {};
+      const existing = fs13.existsSync(destSettingsPath) ? JSON.parse(fs13.readFileSync(destSettingsPath, "utf-8")) : {};
       const merged = { ...existing, ...projectSettings, hooks: existing["hooks"] };
-      fs12.writeFileSync(destSettingsPath, JSON.stringify(merged, null, 2));
+      fs13.writeFileSync(destSettingsPath, JSON.stringify(merged, null, 2));
     } catch {
     }
   }
-  const projectClaudeMd = path13.join(projectClaudeDir, "CLAUDE.md");
-  if (fs12.existsSync(projectClaudeMd)) {
-    fs12.copyFileSync(projectClaudeMd, path13.join(destClaudeDir, "CLAUDE.md"));
+  const projectClaudeMd = path14.join(projectClaudeDir, "CLAUDE.md");
+  if (fs13.existsSync(projectClaudeMd)) {
+    fs13.copyFileSync(projectClaudeMd, path14.join(destClaudeDir, "CLAUDE.md"));
   }
-  const projectAgentsMd = path13.join(projectClaudeDir, "AGENTS.md");
-  if (fs12.existsSync(projectAgentsMd)) {
-    fs12.copyFileSync(projectAgentsMd, path13.join(destClaudeDir, "AGENTS.md"));
+  const projectAgentsMd = path14.join(projectClaudeDir, "AGENTS.md");
+  if (fs13.existsSync(projectAgentsMd)) {
+    fs13.copyFileSync(projectAgentsMd, path14.join(destClaudeDir, "AGENTS.md"));
   }
   for (const subdir of ["rules", "agents", "plugins", "skills", "scripts"]) {
-    const projectSubdir = path13.join(projectClaudeDir, subdir);
-    if (fs12.existsSync(projectSubdir)) {
+    const projectSubdir = path14.join(projectClaudeDir, subdir);
+    if (fs13.existsSync(projectSubdir)) {
       const skip = subdir === "plugins" ? SKIP_FILES : /* @__PURE__ */ new Set();
-      copyDirRecursive(projectSubdir, path13.join(destClaudeDir, subdir), 0, skip);
+      copyDirRecursive(projectSubdir, path14.join(destClaudeDir, subdir), 0, skip);
     }
   }
 }
@@ -7679,8 +7706,8 @@ function stripMcpServers(mcpServers) {
   return out;
 }
 function writeStrippedMcpServersSnapshot(homeDir, workspacePath, destClaudeDir) {
-  const hostMcpServers = readMcpServersFromFile(path13.join(homeDir, ".claude.json"));
-  const projectMcpServers = readMcpServersFromFile(path13.join(workspacePath, ".mcp.json"));
+  const hostMcpServers = readMcpServersFromFile(path14.join(homeDir, ".claude.json"));
+  const projectMcpServers = readMcpServersFromFile(path14.join(workspacePath, ".mcp.json"));
   if (Object.keys(hostMcpServers).length === 0 && Object.keys(projectMcpServers).length === 0) {
     return;
   }
@@ -7689,11 +7716,11 @@ function writeStrippedMcpServersSnapshot(homeDir, workspacePath, destClaudeDir)
     ...stripMcpServers(projectMcpServers)
   };
   const output = { mcpServers: stripped };
-  fs12.writeFileSync(path13.join(destClaudeDir, ".claude.json"), JSON.stringify(output, null, 2), { mode: 384 });
+  fs13.writeFileSync(path14.join(destClaudeDir, ".claude.json"), JSON.stringify(output, null, 2), { mode: 384 });
 }
 function writeWorldEntitlementsJson(workspacePath, configCtx) {
-  const olamDir = path13.join(workspacePath, ".olam");
-  fs12.mkdirSync(olamDir, { recursive: true });
+  const olamDir = path14.join(workspacePath, ".olam");
+  fs13.mkdirSync(olamDir, { recursive: true });
   const resolvedRepos = configCtx.repos.map((repo) => {
     const repoEntitlement = repo;
     return {
@@ -7707,14 +7734,14 @@ function writeWorldEntitlementsJson(workspacePath, configCtx) {
     worlds_default: configCtx.worlds_default,
     repos: resolvedRepos
   };
-  const filePath = path13.join(olamDir, "world-entitlements.json");
-  fs12.writeFileSync(filePath, JSON.stringify(resolved, null, 2), { mode: 420 });
+  const filePath = path14.join(olamDir, "world-entitlements.json");
+  fs13.writeFileSync(filePath, JSON.stringify(resolved, null, 2), { mode: 420 });
 }
 function readMcpServersFromFile(filePath) {
-  if (!fs12.existsSync(filePath))
+  if (!fs13.existsSync(filePath))
     return {};
   try {
-    const raw = fs12.readFileSync(filePath, "utf-8");
+    const raw = fs13.readFileSync(filePath, "utf-8");
     if (!raw.trim())
       return {};
     const parsed = JSON.parse(raw);
@@ -7729,8 +7756,8 @@ function readMcpServersFromFile(filePath) {
 function copyDirRecursive(src, dest, depth = 0, skipFiles = /* @__PURE__ */ new Set()) {
   if (depth > 10)
     return;
-  fs12.mkdirSync(dest, { recursive: true });
-  for (const entry of fs12.readdirSync(src, { withFileTypes: true })) {
+  fs13.mkdirSync(dest, { recursive: true });
+  for (const entry of fs13.readdirSync(src, { withFileTypes: true })) {
     const { name } = entry;
     if (skipFiles.has(name))
       continue;
@@ -7740,12 +7767,12 @@ function copyDirRecursive(src, dest, depth = 0, skipFiles = /* @__PURE__ */ new
       continue;
     if (entry.isDirectory() && SKIP_DIRS_ANYWHERE.has(name))
       continue;
-    const srcPath = path13.join(src, name);
-    const destPath = path13.join(dest, name);
+    const srcPath = path14.join(src, name);
+    const destPath = path14.join(dest, name);
     if (entry.isSymbolicLink()) {
       let stat;
       try {
-        stat = fs12.statSync(srcPath);
+        stat = fs13.statSync(srcPath);
       } catch {
         continue;
       }
@@ -7754,12 +7781,12 @@ function copyDirRecursive(src, dest, depth = 0, skipFiles = /* @__PURE__ */ new
           continue;
         copyDirRecursive(srcPath, destPath, depth + 1, skipFiles);
       } else if (stat.isFile()) {
-        fs12.copyFileSync(srcPath, destPath);
+        fs13.copyFileSync(srcPath, destPath);
       }
     } else if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath, depth + 1, skipFiles);
     } else {
-      fs12.copyFileSync(srcPath, destPath);
+      fs13.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -7897,9 +7924,9 @@ function setupWorldEnv(repos, workspacePath, serviceEnv, crossRepoEnv = {}, conf
     }
   }
   for (const repo of repos) {
-    const worktreePath = path13.join(workspacePath, repo.name);
+    const worktreePath = path14.join(workspacePath, repo.name);
     const sourcePath = repo.path;
-    if (!sourcePath || !fs12.existsSync(worktreePath))
+    if (!sourcePath || !fs13.existsSync(worktreePath))
       continue;
     const envSetup = repo.env_setup;
     if (!envSetup)
@@ -7918,23 +7945,23 @@ function setupWorldEnv(repos, workspacePath, serviceEnv, crossRepoEnv = {}, conf
   }
 }
 function copyMatchingFiles(sourcePath, destPath, pattern) {
-  const fullPattern = path13.join(sourcePath, pattern);
+  const fullPattern = path14.join(sourcePath, pattern);
   if (!pattern.includes("*")) {
-    const sourceFile = path13.join(sourcePath, pattern);
-    const destFile = path13.join(destPath, pattern);
-    if (fs12.existsSync(sourceFile)) {
-      fs12.mkdirSync(path13.dirname(destFile), { recursive: true });
-      fs12.copyFileSync(sourceFile, destFile);
+    const sourceFile = path14.join(sourcePath, pattern);
+    const destFile = path14.join(destPath, pattern);
+    if (fs13.existsSync(sourceFile)) {
+      fs13.mkdirSync(path14.dirname(destFile), { recursive: true });
+      fs13.copyFileSync(sourceFile, destFile);
     }
     return;
   }
   try {
     const matches2 = globSync(fullPattern);
     for (const match2 of matches2) {
-      const relative2 = path13.relative(sourcePath, match2);
-      const dest = path13.join(destPath, relative2);
-      fs12.mkdirSync(path13.dirname(dest), { recursive: true });
-      fs12.copyFileSync(match2, dest);
+      const relative2 = path14.relative(sourcePath, match2);
+      const dest = path14.join(destPath, relative2);
+      fs13.mkdirSync(path14.dirname(dest), { recursive: true });
+      fs13.copyFileSync(match2, dest);
     }
   } catch {
   }
@@ -7942,14 +7969,14 @@ function copyMatchingFiles(sourcePath, destPath, pattern) {
 function generateEnvFromExample(repoPath, overrides) {
   const exampleFiles = [".env.example", ".env.sample", ".env.local.example"];
   for (const exampleName of exampleFiles) {
-    const examplePath = path13.join(repoPath, exampleName);
-    if (!fs12.existsSync(examplePath))
+    const examplePath = path14.join(repoPath, exampleName);
+    if (!fs13.existsSync(examplePath))
       continue;
     const targetName = exampleName.replace(".example", "").replace(".sample", "");
-    const targetPath = path13.join(repoPath, targetName);
-    if (fs12.existsSync(targetPath))
+    const targetPath = path14.join(repoPath, targetName);
+    if (fs13.existsSync(targetPath))
       continue;
-    const template = fs12.readFileSync(examplePath, "utf-8");
+    const template = fs13.readFileSync(examplePath, "utf-8");
     const generated = template.split("\n").map((line) => {
       const match2 = /^([A-Z_][A-Z0-9_]*)=(.*)$/.exec(line);
       if (match2) {
@@ -7960,13 +7987,13 @@ function generateEnvFromExample(repoPath, overrides) {
       }
       return line;
     }).join("\n");
-    fs12.writeFileSync(targetPath, generated);
+    fs13.writeFileSync(targetPath, generated);
   }
 }
 function applyEnvOverrides(repoPath, overrides) {
-  const envPath = path13.join(repoPath, ".env");
-  if (fs12.existsSync(envPath)) {
-    const existing = fs12.readFileSync(envPath, "utf-8");
+  const envPath = path14.join(repoPath, ".env");
+  if (fs13.existsSync(envPath)) {
+    const existing = fs13.readFileSync(envPath, "utf-8");
     const existingKeys = new Set(existing.split("\n").map((l) => l.split("=")[0]?.trim()).filter(Boolean));
     const additions = [];
     for (const [key, value] of Object.entries(overrides)) {
@@ -7975,7 +8002,7 @@ function applyEnvOverrides(repoPath, overrides) {
       }
     }
     if (additions.length > 0) {
-      fs12.appendFileSync(envPath, "\n# Olam injected\n" + additions.join("\n") + "\n");
+      fs13.appendFileSync(envPath, "\n# Olam injected\n" + additions.join("\n") + "\n");
     }
   }
 }
@@ -8053,9 +8080,9 @@ var init_env_setup = __esm({
 
 // ../core/dist/world/baseline-diff.js
 import { execFileSync as execFileSync3 } from "node:child_process";
-import * as fs13 from "node:fs";
+import * as fs14 from "node:fs";
 import * as os9 from "node:os";
-import * as path14 from "node:path";
+import * as path15 from "node:path";
 function expandHome(p, homedir24) {
   return p.replace(/^~(?=$|\/|\\)/, homedir24());
 }
@@ -8081,9 +8108,9 @@ ${stderr}`;
 function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
   const exec = deps.exec ?? ((cmd, args, opts) => execFileSync3(cmd, args, opts));
   const homedir24 = deps.homedir ?? (() => os9.homedir());
-  const baselineDir = path14.join(workspacePath, ".olam", "baseline");
+  const baselineDir = path15.join(workspacePath, ".olam", "baseline");
   try {
-    fs13.mkdirSync(baselineDir, { recursive: true });
+    fs14.mkdirSync(baselineDir, { recursive: true });
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.warn(`[baseline-diff] mkdir ${baselineDir} failed: ${msg}; reaper will see no baseline at all`);
@@ -8095,9 +8122,9 @@ function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
     if (!repo.path)
       continue;
     const filename = `${sanitizeRepoFilename(repo.name)}.diff`;
-    const outPath = path14.join(baselineDir, filename);
+    const outPath = path15.join(baselineDir, filename);
     const repoPath = expandHome(repo.path, homedir24);
-    if (!fs13.existsSync(repoPath)) {
+    if (!fs14.existsSync(repoPath)) {
       writeBaselineFile(outPath, `# repo: ${repo.name}
 # (skipped: path ${repoPath} does not exist)
 `);
@@ -8164,7 +8191,7 @@ function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
 }
 function writeBaselineFile(outPath, content) {
   try {
-    fs13.writeFileSync(outPath, content);
+    fs14.writeFileSync(outPath, content);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.warn(`[baseline-diff] write to ${outPath} failed: ${msg}`);
@@ -8172,8 +8199,8 @@ function writeBaselineFile(outPath, content) {
 }
 function stripWorktreeEdits(repos, workspacePath) {
   for (const repo of repos) {
-    const worktreePath = path14.join(workspacePath, repo.name);
-    if (!fs13.existsSync(worktreePath))
+    const worktreePath = path15.join(workspacePath, repo.name);
+    if (!fs14.existsSync(worktreePath))
       continue;
     try {
       execFileSync3("git", ["checkout", "--", "."], {
@@ -8210,12 +8237,12 @@ var init_baseline_diff = __esm({
 });
 
 // ../core/dist/world/context-injection.js
-import * as fs14 from "node:fs";
-import * as path15 from "node:path";
+import * as fs15 from "node:fs";
+import * as path16 from "node:path";
 function injectWorldContext(opts) {
   const { world, task, linearTicketId, claudeMdExtra, taskContext, services, pleriPlaneUrl } = opts;
-  const claudeDir = path15.join(world.workspacePath, ".claude");
-  fs14.mkdirSync(claudeDir, { recursive: true });
+  const claudeDir = path16.join(world.workspacePath, ".claude");
+  fs15.mkdirSync(claudeDir, { recursive: true });
   const sections = [];
   sections.push(`# Olam World: ${world.name}`);
   sections.push("");
@@ -8376,7 +8403,7 @@ function injectWorldContext(opts) {
     sections.push("");
   }
   const content = sections.join("\n");
-  fs14.writeFileSync(path15.join(claudeDir, "CLAUDE.md"), content);
+  fs15.writeFileSync(path16.join(claudeDir, "CLAUDE.md"), content);
 }
 function formatTaskSource(ctx) {
   if (ctx.source === "linear" && ctx.ticketId) {
@@ -8390,9 +8417,9 @@ function formatTaskSource(ctx) {
 function hasPlanFile(world) {
   if (world.repos.length === 0)
     return false;
-  const plansDir = path15.join(world.workspacePath, world.repos[0], "docs", "plans");
+  const plansDir = path16.join(world.workspacePath, world.repos[0], "docs", "plans");
   try {
-    return fs14.existsSync(plansDir) && fs14.readdirSync(plansDir).length > 0;
+    return fs15.existsSync(plansDir) && fs15.readdirSync(plansDir).length > 0;
   } catch {
     return false;
   }
@@ -9096,14 +9123,14 @@ var init_secrets_fetcher = __esm({
 });
 
 // ../core/dist/world/olam-yaml.js
-import * as path16 from "node:path";
+import * as path17 from "node:path";
 import YAML2 from "yaml";
 function enrichReposWithManifests(repos, workspacePath) {
   return repos.map((repo) => {
     if (repo.manifest !== void 0 && repo.manifest !== null) {
       return repo;
     }
-    const repoDir = path16.join(workspacePath, repo.name);
+    const repoDir = path17.join(workspacePath, repo.name);
     let manifest = null;
     try {
       manifest = loadRepoManifest(repoDir);
@@ -9124,8 +9151,8 @@ var init_olam_yaml = __esm({
 });
 
 // ../core/dist/policies/loader.js
-import * as fs15 from "node:fs";
-import * as path17 from "node:path";
+import * as fs16 from "node:fs";
+import * as path18 from "node:path";
 import { parse as parseYaml3 } from "yaml";
 function parseFrontmatter(content) {
   const match2 = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/m.exec(content);
@@ -9145,20 +9172,20 @@ function toStringArray(v) {
   return v.filter((x) => typeof x === "string");
 }
 function loadPolicies(workspaceRoot) {
-  const policiesDir = path17.join(workspaceRoot, ".olam", "policies");
-  if (!fs15.existsSync(policiesDir))
+  const policiesDir = path18.join(workspaceRoot, ".olam", "policies");
+  if (!fs16.existsSync(policiesDir))
     return [];
   let files;
   try {
-    files = fs15.readdirSync(policiesDir).filter((f) => f.endsWith(".md")).sort();
+    files = fs16.readdirSync(policiesDir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return [];
   }
   const policies = [];
   for (const file of files) {
-    const filePath = path17.join(policiesDir, file);
+    const filePath = path18.join(policiesDir, file);
     try {
-      const content = fs15.readFileSync(filePath, "utf8");
+      const content = fs16.readFileSync(filePath, "utf8");
       const parsed = parseFrontmatter(content);
       if (!parsed) {
         console.warn(`[policies] skipping ${file}: no valid frontmatter block`);
@@ -9332,9 +9359,9 @@ __export(manager_exports, {
 });
 import * as crypto4 from "node:crypto";
 import { execSync as execSync4 } from "node:child_process";
-import * as fs16 from "node:fs";
+import * as fs17 from "node:fs";
 import * as os10 from "node:os";
-import * as path18 from "node:path";
+import * as path19 from "node:path";
 import YAML3 from "yaml";
 function getTokenScopes(ghToken, _exec = execSync4) {
   try {
@@ -9749,7 +9776,7 @@ var init_manager = __esm({
           }
         }
         const worldId = generateWorldId();
-        const workspacePath = path18.join(os10.homedir(), ".olam", "worlds", worldId);
+        const workspacePath = path19.join(os10.homedir(), ".olam", "worlds", worldId);
         const portOffset = this.registry.getNextPortOffset();
         const branch = opts.branchName ?? `olam/${worldId}`;
         const repos = this.resolveReposWithWorkspace(opts);
@@ -9806,37 +9833,37 @@ var init_manager = __esm({
           if (!repo.path)
             continue;
           const sourceRoot = repo.path.replace(/^~/, os10.homedir());
-          const worktreeRoot = path18.join(workspacePath, repo.name);
-          if (!fs16.existsSync(sourceRoot) || !fs16.existsSync(worktreeRoot))
+          const worktreeRoot = path19.join(workspacePath, repo.name);
+          if (!fs17.existsSync(sourceRoot) || !fs17.existsSync(worktreeRoot))
             continue;
           let copied = 0;
           for (const pattern of RUNTIME_FILE_PATTERNS) {
             const matches2 = [];
             if (pattern.includes("*")) {
-              const [dir, glob] = [path18.dirname(pattern), path18.basename(pattern)];
-              const sourceDir = path18.join(sourceRoot, dir);
-              if (fs16.existsSync(sourceDir)) {
+              const [dir, glob] = [path19.dirname(pattern), path19.basename(pattern)];
+              const sourceDir = path19.join(sourceRoot, dir);
+              if (fs17.existsSync(sourceDir)) {
                 const ext2 = glob.replace(/^\*+/, "");
                 try {
-                  for (const entry of fs16.readdirSync(sourceDir)) {
+                  for (const entry of fs17.readdirSync(sourceDir)) {
                     if (ext2 === "" || entry.endsWith(ext2))
-                      matches2.push(path18.join(dir, entry));
+                      matches2.push(path19.join(dir, entry));
                   }
                 } catch {
                 }
               }
-            } else if (fs16.existsSync(path18.join(sourceRoot, pattern))) {
+            } else if (fs17.existsSync(path19.join(sourceRoot, pattern))) {
               matches2.push(pattern);
             }
             for (const rel of matches2) {
-              const src = path18.join(sourceRoot, rel);
-              const dst = path18.join(worktreeRoot, rel);
+              const src = path19.join(sourceRoot, rel);
+              const dst = path19.join(worktreeRoot, rel);
               try {
-                const st = fs16.statSync(src);
+                const st = fs17.statSync(src);
                 if (!st.isFile())
                   continue;
-                fs16.mkdirSync(path18.dirname(dst), { recursive: true });
-                fs16.copyFileSync(src, dst);
+                fs17.mkdirSync(path19.dirname(dst), { recursive: true });
+                fs17.copyFileSync(src, dst);
                 copied++;
               } catch {
               }
@@ -9936,7 +9963,7 @@ var init_manager = __esm({
           try {
             const hostExec = makeHostExecFn();
             for (const repo of repos) {
-              const repoDir = path18.join(workspacePath, repo.name);
+              const repoDir = path19.join(workspacePath, repo.name);
               if (repo.stack && Object.keys(repo.stack).length > 0) {
                 preDetectedStacks.set(repo.name, { repoName: repo.name, versions: repo.stack });
               } else {
@@ -9993,10 +10020,10 @@ var init_manager = __esm({
           const worldEnv = {};
           if (opts.task)
             worldEnv.OLAM_TASK = opts.task;
-          const r2CredsPath = path18.join(os10.homedir(), ".olam", "r2-credentials.json");
-          if (fs16.existsSync(r2CredsPath)) {
+          const r2CredsPath = path19.join(os10.homedir(), ".olam", "r2-credentials.json");
+          if (fs17.existsSync(r2CredsPath)) {
             try {
-              const r2Raw = fs16.readFileSync(r2CredsPath, "utf-8").trim();
+              const r2Raw = fs17.readFileSync(r2CredsPath, "utf-8").trim();
               if (r2Raw.length > 0) {
                 const r2 = JSON.parse(r2Raw);
                 if (typeof r2.account_id === "string")
@@ -10013,10 +10040,10 @@ var init_manager = __esm({
             } catch {
             }
           }
-          const keysYamlPath = path18.join(os10.homedir(), ".olam", "keys.yaml");
-          if (fs16.existsSync(keysYamlPath)) {
+          const keysYamlPath = path19.join(os10.homedir(), ".olam", "keys.yaml");
+          if (fs17.existsSync(keysYamlPath)) {
             try {
-              const keysRaw = fs16.readFileSync(keysYamlPath, "utf-8").trim();
+              const keysRaw = fs17.readFileSync(keysYamlPath, "utf-8").trim();
               if (keysRaw.length > 0) {
                 const parsed = YAML3.parse(keysRaw);
                 if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
@@ -10063,10 +10090,10 @@ var init_manager = __esm({
                 worldEnv[k] = v;
             }
             for (const { repoName, relativePath, content } of fileWrites) {
-              const absPath = path18.join(workspacePath, repoName, relativePath);
+              const absPath = path19.join(workspacePath, repoName, relativePath);
               try {
-                fs16.mkdirSync(path18.dirname(absPath), { recursive: true });
-                fs16.writeFileSync(absPath, content.endsWith("\n") ? content : content + "\n", {
+                fs17.mkdirSync(path19.dirname(absPath), { recursive: true });
+                fs17.writeFileSync(absPath, content.endsWith("\n") ? content : content + "\n", {
                   mode: 384
                 });
                 console.log(`[secrets] ${repoName}: materialised ${relativePath} (${content.length} chars, mode 0600)`);
@@ -10218,7 +10245,7 @@ var init_manager = __esm({
             let taskWithPolicies = opts.task;
             try {
               const allPolicies = repos.flatMap((repo) => {
-                const repoWorktree = path18.join(workspacePath, repo.name);
+                const repoWorktree = path19.join(workspacePath, repo.name);
                 return loadPolicies(repoWorktree);
               });
               const seen = /* @__PURE__ */ new Set();
@@ -10234,8 +10261,8 @@ var init_manager = __esm({
 ${opts.task}`;
                 execSync4(`docker exec ${containerName} mkdir -p /home/olam/.olam/policies`, { stdio: "pipe", timeout: 1e4 });
                 for (const repo of repos) {
-                  const policiesDir = path18.join(workspacePath, repo.name, ".olam", "policies");
-                  if (fs16.existsSync(policiesDir)) {
+                  const policiesDir = path19.join(workspacePath, repo.name, ".olam", "policies");
+                  if (fs17.existsSync(policiesDir)) {
                     execSync4(`docker cp "${policiesDir}/." "${containerName}:/home/olam/.olam/policies/"`, { stdio: "pipe", timeout: 15e3 });
                   }
                 }
@@ -10314,8 +10341,8 @@ ${opts.task}`;
         } catch {
         }
         try {
-          fs16.rmSync(world.workspacePath, { recursive: true, force: true });
-          if (fs16.existsSync(world.workspacePath)) {
+          fs17.rmSync(world.workspacePath, { recursive: true, force: true });
+          if (fs17.existsSync(world.workspacePath)) {
             console.warn(`[WorldManager] destroyWorld(${worldId}): workspace dir ${world.workspacePath} still exists after rmSync. Run \`olam clean --apply\` to reap.`);
           }
         } catch (err) {
@@ -10400,14 +10427,14 @@ ${opts.task}`;
         return names.map((name) => this.config.repos.find((r) => r.name === name)).filter((r) => r !== void 0);
       }
       transportPlanFile(planFilePath, workspacePath, repoNames) {
-        const planContent = fs16.readFileSync(planFilePath, "utf-8");
-        const planFileName = path18.basename(planFilePath);
+        const planContent = fs17.readFileSync(planFilePath, "utf-8");
+        const planFileName = path19.basename(planFilePath);
         const targetRepo = repoNames[0];
         if (!targetRepo)
           return;
-        const plansDir = path18.join(workspacePath, targetRepo, "docs", "plans");
-        fs16.mkdirSync(plansDir, { recursive: true });
-        fs16.writeFileSync(path18.join(plansDir, planFileName), planContent);
+        const plansDir = path19.join(workspacePath, targetRepo, "docs", "plans");
+        fs17.mkdirSync(plansDir, { recursive: true });
+        fs17.writeFileSync(path19.join(plansDir, planFileName), planContent);
       }
       resolveServices(repos) {
         const services = [];
@@ -10500,9 +10527,9 @@ var init_tracker = __esm({
 });
 
 // ../core/dist/world-paths.js
-import * as path19 from "node:path";
+import * as path20 from "node:path";
 function getWorldDbPath(workspacePath) {
-  return path19.join(workspacePath, WORLD_DB_FILENAME);
+  return path20.join(workspacePath, WORLD_DB_FILENAME);
 }
 var WORLD_DB_FILENAME;
 var init_world_paths = __esm({
@@ -11120,9 +11147,9 @@ var init_session_aggregator = __esm({
 
 // ../core/dist/dashboard/server.js
 import * as http from "node:http";
-import * as fs17 from "node:fs";
-import * as path20 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import * as fs18 from "node:fs";
+import * as path21 from "node:path";
+import { fileURLToPath as fileURLToPath3 } from "node:url";
 function jsonResponse(res, data, status = 200) {
   res.writeHead(status, { "Content-Type": "application/json; charset=utf-8" });
   res.end(JSON.stringify(data));
@@ -11132,7 +11159,7 @@ function notFound(res) {
 }
 function openThoughtStore(workspacePath) {
   const dbPath = getWorldDbPath(workspacePath);
-  if (!fs17.existsSync(dbPath))
+  if (!fs18.existsSync(dbPath))
     return null;
   return new ThoughtLocalStore(dbPath);
 }
@@ -11303,13 +11330,13 @@ function findSessionInWorld(registry, sessionId) {
 }
 function createDashboardServer(opts) {
   const { port, registry } = opts;
-  const thisDir = path20.dirname(fileURLToPath2(import.meta.url));
-  const defaultPublicDir = path20.resolve(thisDir, "../../../control-plane/public");
+  const thisDir = path21.dirname(fileURLToPath3(import.meta.url));
+  const defaultPublicDir = path21.resolve(thisDir, "../../../control-plane/public");
   const publicDir = opts.publicDir ?? defaultPublicDir;
-  let hasPublicDir = fs17.existsSync(publicDir);
+  let hasPublicDir = fs18.existsSync(publicDir);
   const server = http.createServer((req, res) => {
     if (!hasPublicDir) {
-      hasPublicDir = fs17.existsSync(publicDir);
+      hasPublicDir = fs18.existsSync(publicDir);
     }
     const host = req.headers.host ?? `localhost:${port}`;
     const url = new URL(req.url ?? "/", `http://${host}`);
@@ -11583,22 +11610,22 @@ function createDashboardServer(opts) {
       res.end(`<html><body style="font-family:system-ui;padding:2rem"><h1>Olam Dashboard</h1><p>The React app has not been built yet.</p><p>Run <code>npm run build:app</code> in <code>packages/control-plane</code> to build it.</p><p>API routes are available at <code>/api/*</code>.</p></body></html>`);
       return;
     }
-    let filePath = path20.join(publicDir, pathname === "/" ? "index.html" : pathname);
+    let filePath = path21.join(publicDir, pathname === "/" ? "index.html" : pathname);
     if (!filePath.startsWith(publicDir)) {
       notFound(res);
       return;
     }
-    if (fs17.existsSync(filePath) && fs17.statSync(filePath).isFile()) {
-      const ext2 = path20.extname(filePath);
+    if (fs18.existsSync(filePath) && fs18.statSync(filePath).isFile()) {
+      const ext2 = path21.extname(filePath);
       const contentType = MIME[ext2] ?? "application/octet-stream";
       res.writeHead(200, { "Content-Type": contentType });
-      fs17.createReadStream(filePath).pipe(res);
+      fs18.createReadStream(filePath).pipe(res);
       return;
     }
-    filePath = path20.join(publicDir, "index.html");
-    if (fs17.existsSync(filePath)) {
+    filePath = path21.join(publicDir, "index.html");
+    if (fs18.existsSync(filePath)) {
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-      fs17.createReadStream(filePath).pipe(res);
+      fs18.createReadStream(filePath).pipe(res);
       return;
     }
     notFound(res);
@@ -11629,16 +11656,16 @@ var init_server = __esm({
 });
 
 // ../core/dist/dashboard/state.js
-import * as fs18 from "node:fs";
+import * as fs19 from "node:fs";
 import * as os11 from "node:os";
-import * as path21 from "node:path";
+import * as path22 from "node:path";
 function saveDashboardState(state) {
-  fs18.mkdirSync(path21.dirname(STATE_PATH), { recursive: true });
-  fs18.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2));
+  fs19.mkdirSync(path22.dirname(STATE_PATH), { recursive: true });
+  fs19.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2));
 }
 function loadDashboardState() {
   try {
-    const raw = fs18.readFileSync(STATE_PATH, "utf-8");
+    const raw = fs19.readFileSync(STATE_PATH, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -11646,7 +11673,7 @@ function loadDashboardState() {
 }
 function clearDashboardState() {
   try {
-    fs18.unlinkSync(STATE_PATH);
+    fs19.unlinkSync(STATE_PATH);
   } catch {
   }
 }
@@ -11666,7 +11693,7 @@ var STATE_PATH;
 var init_state2 = __esm({
   "../core/dist/dashboard/state.js"() {
     "use strict";
-    STATE_PATH = path21.join(os11.homedir(), ".olam", "dashboard.json");
+    STATE_PATH = path22.join(os11.homedir(), ".olam", "dashboard.json");
   }
 });
 
@@ -12061,50 +12088,50 @@ __export(host_cp_exports, {
   writeToken: () => writeToken
 });
 import * as crypto5 from "node:crypto";
-import * as fs19 from "node:fs";
+import * as fs20 from "node:fs";
 import * as os12 from "node:os";
-import * as path22 from "node:path";
+import * as path23 from "node:path";
 import { spawnSync as spawnSync4 } from "node:child_process";
 import Dockerode2 from "dockerode";
 function findComposeFile() {
   const candidates = [
     // Bundled path: dist/index.js lives at <pkg>/dist/; host-cp/ is a sibling of dist/
-    path22.resolve(path22.dirname(new URL(import.meta.url).pathname), "../host-cp/compose.yaml"),
+    path23.resolve(path23.dirname(new URL(import.meta.url).pathname), "../host-cp/compose.yaml"),
     // Source-mode: cwd is monorepo root
-    path22.resolve(process.cwd(), "packages/host-cp/compose.yaml"),
+    path23.resolve(process.cwd(), "packages/host-cp/compose.yaml"),
     // Source-mode: cwd is one level inside the monorepo
-    path22.resolve(process.cwd(), "../packages/host-cp/compose.yaml")
+    path23.resolve(process.cwd(), "../packages/host-cp/compose.yaml")
   ];
   for (const c of candidates) {
-    if (fs19.existsSync(c)) return c;
+    if (fs20.existsSync(c)) return c;
   }
-  return path22.resolve(process.cwd(), "packages/host-cp/compose.yaml");
+  return path23.resolve(process.cwd(), "packages/host-cp/compose.yaml");
 }
 function olamHome() {
-  return process.env.OLAM_HOME ?? path22.join(os12.homedir(), ".olam");
+  return process.env.OLAM_HOME ?? path23.join(os12.homedir(), ".olam");
 }
 function tokenPath() {
-  return path22.join(olamHome(), "host-cp.token");
+  return path23.join(olamHome(), "host-cp.token");
 }
 function pidPath() {
-  return path22.join(olamHome(), "host-cp.pid");
+  return path23.join(olamHome(), "host-cp.pid");
 }
 function authSecretPath() {
-  return path22.join(olamHome(), "auth-secret");
+  return path23.join(olamHome(), "auth-secret");
 }
 function readAuthSecret2() {
   const filePath = authSecretPath();
-  if (!fs19.existsSync(filePath)) return null;
-  const raw = fs19.readFileSync(filePath, "utf-8").trim();
+  if (!fs20.existsSync(filePath)) return null;
+  const raw = fs20.readFileSync(filePath, "utf-8").trim();
   return raw.length > 0 ? raw : null;
 }
 function r2CredentialsPath() {
-  return path22.join(olamHome(), "r2-credentials.json");
+  return path23.join(olamHome(), "r2-credentials.json");
 }
 function readR2Credentials() {
   const filePath = r2CredentialsPath();
-  if (!fs19.existsSync(filePath)) return null;
-  const raw = fs19.readFileSync(filePath, "utf-8").trim();
+  if (!fs20.existsSync(filePath)) return null;
+  const raw = fs20.readFileSync(filePath, "utf-8").trim();
   if (raw.length === 0) return null;
   try {
     const parsed = JSON.parse(raw);
@@ -12127,37 +12154,37 @@ function readR2Credentials() {
 function writeToken() {
   const token = crypto5.randomBytes(32).toString("hex");
   const filePath = tokenPath();
-  fs19.mkdirSync(path22.dirname(filePath), { recursive: true });
-  fs19.writeFileSync(filePath, token, { mode: 384 });
+  fs20.mkdirSync(path23.dirname(filePath), { recursive: true });
+  fs20.writeFileSync(filePath, token, { mode: 384 });
   return token;
 }
 function readToken() {
   const filePath = tokenPath();
-  if (!fs19.existsSync(filePath)) return null;
-  return fs19.readFileSync(filePath, "utf-8").trim();
+  if (!fs20.existsSync(filePath)) return null;
+  return fs20.readFileSync(filePath, "utf-8").trim();
 }
 function removeToken() {
   const filePath = tokenPath();
-  if (!fs19.existsSync(filePath)) return false;
-  fs19.unlinkSync(filePath);
+  if (!fs20.existsSync(filePath)) return false;
+  fs20.unlinkSync(filePath);
   return true;
 }
 function writePid(pid) {
   const filePath = pidPath();
-  fs19.mkdirSync(path22.dirname(filePath), { recursive: true });
-  fs19.writeFileSync(filePath, String(pid), { mode: 420 });
+  fs20.mkdirSync(path23.dirname(filePath), { recursive: true });
+  fs20.writeFileSync(filePath, String(pid), { mode: 420 });
 }
 function readPid() {
   const filePath = pidPath();
-  if (!fs19.existsSync(filePath)) return null;
-  const raw = fs19.readFileSync(filePath, "utf-8").trim();
+  if (!fs20.existsSync(filePath)) return null;
+  const raw = fs20.readFileSync(filePath, "utf-8").trim();
   const n = parseInt(raw, 10);
   return Number.isFinite(n) ? n : null;
 }
 function removePid() {
   const filePath = pidPath();
-  if (!fs19.existsSync(filePath)) return false;
-  fs19.unlinkSync(filePath);
+  if (!fs20.existsSync(filePath)) return false;
+  fs20.unlinkSync(filePath);
   return true;
 }
 async function findHostCpContainer() {
@@ -12269,6 +12296,10 @@ function buildComposeEnv(authSecret, ghToken) {
   if (ghToken != null && ghToken.length > 0) {
     env.GH_TOKEN = ghToken;
   }
+  const cliVersion = readCliVersion();
+  if (cliVersion && cliVersion !== "0.0.0-unknown") {
+    env.OLAM_CLI_VERSION = cliVersion;
+  }
   return env;
 }
 function captureGhToken() {
@@ -12316,7 +12347,7 @@ async function handleStart(opts) {
   }
   const token = writeToken();
   const composeFile = findComposeFile();
-  if (!fs19.existsSync(composeFile)) {
+  if (!fs20.existsSync(composeFile)) {
     printError(`compose.yaml not found at ${composeFile}. Run from the olam project root.`);
     removeToken();
     process.exitCode = 1;
@@ -12398,7 +12429,7 @@ async function stopHostCp() {
 }
 async function handleStop() {
   const composeFile = findComposeFile();
-  if (!fs19.existsSync(composeFile)) {
+  if (!fs20.existsSync(composeFile)) {
     printWarning(`compose.yaml not found at ${composeFile}. Cleaning up token + PID anyway.`);
     removeToken();
     removePid();
@@ -12426,13 +12457,13 @@ async function buildStatusReport() {
   const container = await findHostCpContainer();
   const health = await probeHealth();
   const tokenFile = tokenPath();
-  const tokenPresent = fs19.existsSync(tokenFile);
+  const tokenPresent = fs20.existsSync(tokenFile);
   let tokenModeOk = false;
   if (tokenPresent) {
-    const mode = fs19.statSync(tokenFile).mode & 511;
+    const mode = fs20.statSync(tokenFile).mode & 511;
     tokenModeOk = mode === 384;
   }
-  const pidPresent = fs19.existsSync(pidPath());
+  const pidPresent = fs20.existsSync(pidPath());
   let stack;
   if (!container) {
     stack = "not_started";
@@ -12520,8 +12551,8 @@ async function discoverWorldPort(worldId) {
 }
 async function readHostCpToken2() {
   const tp = tokenPath();
-  if (!fs19.existsSync(tp)) return null;
-  return fs19.readFileSync(tp, "utf-8").trim();
+  if (!fs20.existsSync(tp)) return null;
+  return fs20.readFileSync(tp, "utf-8").trim();
 }
 async function callHostCpProxy(method, worldId, path46, body) {
   const token = await readHostCpToken2();
@@ -12637,6 +12668,7 @@ var init_host_cp = __esm({
     init_dist();
     init_output();
     init_docker_host();
+    init_cli_version();
     init_open_url();
     HOST_CP_PORT = 19e3;
     SIDECAR_PULL_SERVICE = "docker-socket-proxy";
@@ -12651,17 +12683,17 @@ __export(install_root_exports, {
   isDevMode: () => isDevMode,
   resolveBuildScript: () => resolveBuildScript
 });
-import { existsSync as existsSync18 } from "node:fs";
-import { dirname as dirname13, join as join24, resolve as resolve6 } from "node:path";
-import { fileURLToPath as fileURLToPath3 } from "node:url";
+import { existsSync as existsSync19 } from "node:fs";
+import { dirname as dirname14, join as join25, resolve as resolve6 } from "node:path";
+import { fileURLToPath as fileURLToPath4 } from "node:url";
 function installRoot(metaUrl = import.meta.url) {
-  const here = fileURLToPath3(metaUrl);
-  return resolve6(dirname13(here), "..");
+  const here = fileURLToPath4(metaUrl);
+  return resolve6(dirname14(here), "..");
 }
 function isDevMode(env = process.env, installRootDir = installRoot()) {
   if (env.OLAM_DEV !== "1") return false;
   const repoRoot = resolve6(installRootDir, "..", "..");
-  return existsSync18(join24(repoRoot, "packages")) && existsSync18(join24(repoRoot, "package.json"));
+  return existsSync19(join25(repoRoot, "packages")) && existsSync19(join25(repoRoot, "package.json"));
 }
 function resolveBuildScript(input) {
   const { scriptRelPath, env = process.env, installRootDir = installRoot() } = input;
@@ -12669,7 +12701,7 @@ function resolveBuildScript(input) {
     throw new MissingBuildScriptError(scriptRelPath);
   }
   const repoRoot = resolve6(installRootDir, "..", "..");
-  return join24(repoRoot, scriptRelPath);
+  return join25(repoRoot, scriptRelPath);
 }
 var MissingBuildScriptError;
 var init_install_root = __esm({
@@ -12840,20 +12872,20 @@ var init_registry_allowlist = __esm({
 });
 
 // ../core/dist/world/world-yaml.js
-import * as fs21 from "node:fs";
-import * as path24 from "node:path";
+import * as fs22 from "node:fs";
+import * as path25 from "node:path";
 import { parse as parseYaml4, stringify as stringifyYaml4 } from "yaml";
 function writeWorldYaml(worldPath, data) {
-  const olamDir = path24.join(worldPath, ".olam");
-  fs21.mkdirSync(olamDir, { recursive: true });
-  fs21.writeFileSync(path24.join(olamDir, "world.yaml"), stringifyYaml4(data), "utf-8");
+  const olamDir = path25.join(worldPath, ".olam");
+  fs22.mkdirSync(olamDir, { recursive: true });
+  fs22.writeFileSync(path25.join(olamDir, "world.yaml"), stringifyYaml4(data), "utf-8");
 }
 function readWorldYaml(worldPath) {
-  const yamlPath = path24.join(worldPath, ".olam", "world.yaml");
-  if (!fs21.existsSync(yamlPath))
+  const yamlPath = path25.join(worldPath, ".olam", "world.yaml");
+  if (!fs22.existsSync(yamlPath))
     return null;
   try {
-    const raw = fs21.readFileSync(yamlPath, "utf-8");
+    const raw = fs22.readFileSync(yamlPath, "utf-8");
     const parsed = parseYaml4(raw);
     return WorldYamlSchema.parse(parsed);
   } catch {
@@ -12984,16 +13016,16 @@ __export(machine_schema_exports, {
   readMachineConfig: () => readMachineConfig,
   writeMachineConfig: () => writeMachineConfig
 });
-import * as fs35 from "node:fs";
-import * as path39 from "node:path";
+import * as fs36 from "node:fs";
+import * as path40 from "node:path";
 import * as os21 from "node:os";
 import { parse as parseYaml5, stringify as stringifyYaml5 } from "yaml";
 function readMachineConfig(configPath) {
   const p = configPath ?? DEFAULT_CONFIG_PATH;
-  if (!fs35.existsSync(p))
+  if (!fs36.existsSync(p))
     return null;
   try {
-    const raw = fs35.readFileSync(p, "utf-8");
+    const raw = fs36.readFileSync(p, "utf-8");
     const parsed = parseYaml5(raw);
     return MachineConfigSchema.parse(parsed);
   } catch {
@@ -13002,8 +13034,8 @@ function readMachineConfig(configPath) {
 }
 function writeMachineConfig(config, configPath) {
   const p = configPath ?? DEFAULT_CONFIG_PATH;
-  fs35.mkdirSync(path39.dirname(p), { recursive: true });
-  fs35.writeFileSync(p, stringifyYaml5({ ...config }), { mode: 420 });
+  fs36.mkdirSync(path40.dirname(p), { recursive: true });
+  fs36.writeFileSync(p, stringifyYaml5({ ...config }), { mode: 420 });
 }
 function initMachineConfig(opts = {}) {
   const configPath = opts.configPath ?? DEFAULT_CONFIG_PATH;
@@ -13026,22 +13058,20 @@ 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(() => path39.join(os21.homedir(), ".olam", "worlds"))
+      worlds_dir: external_exports.string().default(() => path40.join(os21.homedir(), ".olam", "worlds"))
     });
-    DEFAULT_CONFIG_PATH = path39.join(os21.homedir(), ".olam", "config.yaml");
+    DEFAULT_CONFIG_PATH = path40.join(os21.homedir(), ".olam", "config.yaml");
   }
 });
 
 // src/index.ts
+init_cli_version();
 import { Command } from "commander";
-import * as fs42 from "node:fs";
-import * as path45 from "node:path";
-import { fileURLToPath as fileURLToPath4 } from "node:url";
 
 // src/commands/init.ts
 init_output();
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
 import { execSync } from "node:child_process";
 import pc3 from "picocolors";
 
@@ -13049,8 +13079,8 @@ import pc3 from "picocolors";
 init_workspace();
 init_loader();
 init_output();
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
+import * as fs5 from "node:fs";
+import * as path5 from "node:path";
 import pc2 from "picocolors";
 import { stringify as stringifyYaml2 } from "yaml";
 function printWorkspaceNotFound(name) {
@@ -13144,7 +13174,7 @@ function registerWorkspace(program2) {
         updatedAt: Date.now()
       };
       writeWorkspace(ws, { force: opts.force });
-      const file = path4.join(workspacesDir(), `${name}.yaml`);
+      const file = path5.join(workspacesDir(), `${name}.yaml`);
       printSuccess(`Created workspace "${name}" (${repos.length} repo${repos.length === 1 ? "" : "s"})`);
       printInfo("File", file);
       printInfo("Next", `olam create --name <world> --workspace ${name} --task "..."`);
@@ -13168,7 +13198,7 @@ function ensureProjectWorkspaceFromConfig(projectRoot, workspaceName) {
     }
   })();
   if (existing) {
-    return { created: false, file: path4.join(workspacesDir(), `${workspaceName}.yaml`) };
+    return { created: false, file: path5.join(workspacesDir(), `${workspaceName}.yaml`) };
   }
   const cfg = loadConfig(projectRoot);
   const repos = cfg.repos.map((r) => ({
@@ -13182,15 +13212,15 @@ function ensureProjectWorkspaceFromConfig(projectRoot, workspaceName) {
     updatedAt: Date.now()
   };
   writeWorkspace(ws);
-  const file = path4.join(workspacesDir(), `${workspaceName}.yaml`);
+  const file = path5.join(workspacesDir(), `${workspaceName}.yaml`);
   return { created: true, file };
 }
 
 // src/commands/init.ts
 function detectProjectType(root) {
-  if (fs5.existsSync(path5.join(root, "Gemfile")) || fs5.existsSync(path5.join(root, "config", "routes.rb"))) return "rails";
-  if (fs5.existsSync(path5.join(root, "package.json"))) return "node";
-  if (fs5.existsSync(path5.join(root, "pyproject.toml")) || fs5.existsSync(path5.join(root, "requirements.txt"))) return "python";
+  if (fs6.existsSync(path6.join(root, "Gemfile")) || fs6.existsSync(path6.join(root, "config", "routes.rb"))) return "rails";
+  if (fs6.existsSync(path6.join(root, "package.json"))) return "node";
+  if (fs6.existsSync(path6.join(root, "pyproject.toml")) || fs6.existsSync(path6.join(root, "requirements.txt"))) return "python";
   return "generic";
 }
 function getRepoName(root) {
@@ -13203,13 +13233,13 @@ function getRepoName(root) {
     if (match2) return match2[1];
   } catch {
   }
-  return path5.basename(root);
+  return path6.basename(root);
 }
 function findProjectRoot(startDir) {
-  let current = path5.resolve(startDir);
+  let current = path6.resolve(startDir);
   while (true) {
-    if (fs5.existsSync(path5.join(current, ".git"))) return current;
-    const parent = path5.dirname(current);
+    if (fs6.existsSync(path6.join(current, ".git"))) return current;
+    const parent = path6.dirname(current);
     if (parent === current) return startDir;
     current = parent;
   }
@@ -13218,8 +13248,8 @@ function registerInit(program2) {
   program2.command("init").description("Initialize olam in the current project").option("--path <path>", "Project root path", process.cwd()).option("--skip-pleri", "Skip Pleri setup").action(async (opts) => {
     try {
       const projectRoot = findProjectRoot(opts.path);
-      const olamDir = path5.join(projectRoot, ".olam");
-      if (fs5.existsSync(path5.join(olamDir, "config.yaml"))) {
+      const olamDir = path6.join(projectRoot, ".olam");
+      if (fs6.existsSync(path6.join(olamDir, "config.yaml"))) {
         printError(`Already initialized at ${olamDir}/config.yaml`);
         process.exitCode = 1;
         return;
@@ -13235,8 +13265,8 @@ function registerInit(program2) {
       } catch {
         remoteUrl = `git@github.com:your-org/${repoName}.git`;
       }
-      fs5.mkdirSync(path5.join(olamDir, "state"), { recursive: true });
-      fs5.mkdirSync(path5.join(olamDir, "thoughts"), { recursive: true });
+      fs6.mkdirSync(path6.join(olamDir, "state"), { recursive: true });
+      fs6.mkdirSync(path6.join(olamDir, "thoughts"), { recursive: true });
       const pleriSection = opts.skipPleri ? "# pleri:\n#   base_url: ${PLERI_BASE_URL}\n#   plane_id: ${PLERI_PLANE_ID}\n#   api_key: ${PLERI_API_KEY}\n" : "pleri:\n  base_url: ${PLERI_BASE_URL}\n  plane_id: ${PLERI_PLANE_ID}\n  api_key: ${PLERI_API_KEY}\n";
       const config = [
         "version: 2",
@@ -13264,7 +13294,7 @@ function registerInit(program2) {
         "  mode: oauth",
         ""
       ].join("\n");
-      fs5.writeFileSync(path5.join(olamDir, "config.yaml"), config);
+      fs6.writeFileSync(path6.join(olamDir, "config.yaml"), config);
       const envExample = [
         "# Pleri credentials",
         "PLERI_BASE_URL=https://pleri.dev/api",
@@ -13272,7 +13302,7 @@ function registerInit(program2) {
         "PLERI_API_KEY=",
         ""
       ].join("\n");
-      fs5.writeFileSync(path5.join(olamDir, ".env.example"), envExample);
+      fs6.writeFileSync(path6.join(olamDir, ".env.example"), envExample);
       printHeader("Olam initialized");
       printInfo("Config", `${olamDir}/config.yaml`);
       printInfo("Project", `${projectType} (detected)`);
@@ -13297,9 +13327,9 @@ ${pc3.dim(`Next: olam create --name my-world --workspace ${repoName} --task "...
 }
 
 // src/commands/install.ts
-import * as fs6 from "node:fs";
+import * as fs7 from "node:fs";
 import * as os3 from "node:os";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 import pc4 from "picocolors";
 import { stringify as stringifyYaml3 } from "yaml";
 
@@ -13442,11 +13472,11 @@ function walk(name, acc, stack) {
 
 // src/commands/install.ts
 init_output();
-var ROLE_FILE_PATH = path6.join(os3.homedir(), ".olam", "role.yaml");
+var ROLE_FILE_PATH = path7.join(os3.homedir(), ".olam", "role.yaml");
 function readRoleFile() {
-  if (!fs6.existsSync(ROLE_FILE_PATH)) return null;
+  if (!fs7.existsSync(ROLE_FILE_PATH)) return null;
   try {
-    const raw = fs6.readFileSync(ROLE_FILE_PATH, "utf-8");
+    const raw = fs7.readFileSync(ROLE_FILE_PATH, "utf-8");
     const m = /archetype:\s*(\S+)/.exec(raw);
     if (!m) return null;
     const archetype = m[1];
@@ -13466,13 +13496,13 @@ function readRoleFile() {
   }
 }
 function writeRoleFile(role) {
-  fs6.mkdirSync(path6.dirname(ROLE_FILE_PATH), { recursive: true });
+  fs7.mkdirSync(path7.dirname(ROLE_FILE_PATH), { recursive: true });
   const yaml = stringifyYaml3({
     archetype: role.archetype,
     customCapabilities: [...role.customCapabilities],
     installedAt: role.installedAt
   });
-  fs6.writeFileSync(ROLE_FILE_PATH, yaml, { mode: 420 });
+  fs7.writeFileSync(ROLE_FILE_PATH, yaml, { mode: 420 });
 }
 function nextStepsFor(archetype) {
   switch (archetype) {
@@ -13613,21 +13643,21 @@ import * as readline from "node:readline/promises";
 import { spawn as spawn3 } from "node:child_process";
 
 // src/commands/auth-status.ts
-import * as fs8 from "node:fs";
+import * as fs9 from "node:fs";
 import * as os5 from "node:os";
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 import pc5 from "picocolors";
 init_auth();
 init_output();
 init_exit_codes();
-var LOCAL_DATA_DIR = path9.join(os5.homedir(), ".olam", "auth-data");
+var LOCAL_DATA_DIR = path10.join(os5.homedir(), ".olam", "auth-data");
 
 // src/commands/auth-upgrade.ts
 init_output();
 init_host_cp();
 init_auth();
-import * as fs20 from "node:fs";
-import * as path23 from "node:path";
+import * as fs21 from "node:fs";
+import * as path24 from "node:path";
 import { spawnSync as spawnSync7 } from "node:child_process";
 import ora2 from "ora";
 import pc7 from "picocolors";
@@ -13638,20 +13668,20 @@ init_exit_codes();
 init_protocol_version();
 init_output();
 import { spawn as spawn2, spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync19, readFileSync as readFileSync15 } from "node:fs";
-import { join as join25 } from "node:path";
+import { existsSync as existsSync20, readFileSync as readFileSync16 } from "node:fs";
+import { join as join26 } from "node:path";
 import ora from "ora";
 import pc6 from "picocolors";
 function loadImageDigests(installRootDir = installRoot()) {
-  const digestsPath = join25(installRootDir, "dist", "image-digests.json");
-  if (!existsSync19(digestsPath)) {
+  const digestsPath = join26(installRootDir, "dist", "image-digests.json");
+  if (!existsSync20(digestsPath)) {
     throw new Error(
       `image-digests.json missing at ${digestsPath}. Re-run \`npm install -g @pleri/olam-cli@<version>\` to refresh the tarball.`
     );
   }
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync15(digestsPath, "utf8"));
+    parsed = JSON.parse(readFileSync16(digestsPath, "utf8"));
   } catch (err) {
     throw new Error(`image-digests.json is not valid JSON: ${err.message}`);
   }
@@ -13968,8 +13998,8 @@ function parseAuthUpgradeOpts(raw) {
   };
 }
 function validateAuthRepoRoot(cwd) {
-  const marker = path23.join(cwd, "packages/auth-service/Dockerfile");
-  if (!fs20.existsSync(marker)) {
+  const marker = path24.join(cwd, "packages/auth-service/Dockerfile");
+  if (!fs21.existsSync(marker)) {
     return {
       ok: false,
       error: `Not an olam repo root (expected ${marker}).
@@ -14703,15 +14733,15 @@ ${pc9.dim("Next: olam create --name my-world")}`);
 // src/commands/create.ts
 init_manager();
 import { spawnSync as spawnSync9 } from "node:child_process";
-import { existsSync as existsSync22 } from "node:fs";
-import { dirname as dirname14, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync23 } from "node:fs";
+import { dirname as dirname15, resolve as resolve7 } from "node:path";
 import ora3 from "ora";
 import pc10 from "picocolors";
 
 // ../core/dist/world/devbox-freshness.js
 import { execSync as execSync6 } from "node:child_process";
-import { existsSync as existsSync21, statSync as statSync5 } from "node:fs";
-import { join as join27 } from "node:path";
+import { existsSync as existsSync22, statSync as statSync5 } from "node:fs";
+import { join as join28 } from "node:path";
 var DEFAULT_DEVBOX_IMAGE = "olam-devbox:latest";
 var DEVBOX_BAKED_SOURCES = [
   "packages/adapters/src/docker/devbox.Dockerfile",
@@ -14747,7 +14777,7 @@ function getDevboxFreshness(deps) {
   }
   const newerSources = [];
   for (const relPath of DEVBOX_BAKED_SOURCES) {
-    const absPath = join27(deps.repoRoot, relPath);
+    const absPath = join28(deps.repoRoot, relPath);
     const mtimeMs = statMtime(absPath);
     if (mtimeMs === null)
       continue;
@@ -14800,7 +14830,7 @@ function defaultDockerInspect(image) {
 }
 function defaultStatMtime(absPath) {
   try {
-    if (!existsSync21(absPath))
+    if (!existsSync22(absPath))
       return null;
     return statSync5(absPath).mtimeMs;
   } catch {
@@ -15296,10 +15326,10 @@ ${pc10.cyan("Host CP UI:")} ${worldUrl}`);
 function resolveRepoRoot(start) {
   let cur = start;
   while (true) {
-    if (existsSync22(resolve7(cur, "packages")) && existsSync22(resolve7(cur, "package.json"))) {
+    if (existsSync23(resolve7(cur, "packages")) && existsSync23(resolve7(cur, "package.json"))) {
       return cur;
     }
-    const parent = dirname14(cur);
+    const parent = dirname15(cur);
     if (parent === cur) return start;
     cur = parent;
   }
@@ -15527,9 +15557,9 @@ function registerList(program2) {
 
 // src/commands/status.ts
 init_output();
-import * as fs22 from "node:fs";
+import * as fs23 from "node:fs";
 import * as os13 from "node:os";
-import * as path25 from "node:path";
+import * as path26 from "node:path";
 var CLI_VERSION2 = process.env["OLAM_CLI_VERSION"] ?? "0.0.0";
 var HOST_CP_PORT2 = 19e3;
 async function getMachineStatus(_probe, _loadCtx, _readToken) {
@@ -15559,14 +15589,14 @@ async function getMachineStatus(_probe, _loadCtx, _readToken) {
     }
   } catch {
   }
-  const manifestPath2 = path25.join(os13.homedir(), ".olam", "cache", "manifest.json");
+  const manifestPath2 = path26.join(os13.homedir(), ".olam", "cache", "manifest.json");
   let updateAvailable = null;
   let lastUpdateCheck = null;
-  if (fs22.existsSync(manifestPath2)) {
-    const mtime = fs22.statSync(manifestPath2).mtime;
+  if (fs23.existsSync(manifestPath2)) {
+    const mtime = fs23.statSync(manifestPath2).mtime;
     lastUpdateCheck = mtime.toISOString();
     try {
-      const manifest = JSON.parse(fs22.readFileSync(manifestPath2, "utf-8"));
+      const manifest = JSON.parse(fs23.readFileSync(manifestPath2, "utf-8"));
       const latest = manifest["version"];
       updateAvailable = latest !== void 0 && latest !== CLI_VERSION2;
     } catch {
@@ -15689,9 +15719,9 @@ function registerDestroy(program2) {
 // src/commands/clean.ts
 init_context();
 init_output();
-import fs23 from "node:fs";
+import fs24 from "node:fs";
 import os14 from "node:os";
-import path26 from "node:path";
+import path27 from "node:path";
 import { execFileSync as execFileSync5 } from "node:child_process";
 function registerClean(program2) {
   program2.command("clean").description("Reap orphan world filesystem state under ~/.olam/worlds/").option("--apply", "Actually delete the orphans (default is dry-run)", false).option(
@@ -15715,8 +15745,8 @@ async function runClean(opts) {
     printError(error?.message ?? "Olam is not configured. Run `olam init` first.");
     return 1;
   }
-  const worldsDir = path26.join(os14.homedir(), ".olam", "worlds");
-  if (!fs23.existsSync(worldsDir)) {
+  const worldsDir = path27.join(os14.homedir(), ".olam", "worlds");
+  if (!fs24.existsSync(worldsDir)) {
     if (opts.json) {
       process.stdout.write(`${JSON.stringify({ worldsDir, entries: [] })}
 `);
@@ -15731,8 +15761,8 @@ async function runClean(opts) {
   }
   const worktreeMap = collectWorktrees(worldsDir);
   const entries = [];
-  for (const id of fs23.readdirSync(worldsDir).sort()) {
-    const fullPath = path26.join(worldsDir, id);
+  for (const id of fs24.readdirSync(worldsDir).sort()) {
+    const fullPath = path27.join(worldsDir, id);
     const stat = safeStat(fullPath);
     if (!stat || !stat.isDirectory()) continue;
     entries.push(classifyWorld({ id, fullPath, liveIds, worktreeMap }));
@@ -15798,7 +15828,7 @@ function classifyWorld(args) {
   if (liveIds.has(id)) {
     return { id, path: fullPath, bytes, category: "active", note: "in registry" };
   }
-  const worktreeChild = path26.join(fullPath, "olam");
+  const worktreeChild = path27.join(fullPath, "olam");
   const worktreeInfo = worktreeMap.get(worktreeChild);
   if (worktreeInfo) {
     if (worktreeInfo.dirty > 0 || worktreeInfo.unpushed > 0) {
@@ -15844,20 +15874,20 @@ function reapEntry(entry) {
     }
   }
   try {
-    fs23.rmSync(entry.path, { recursive: true, force: true });
+    fs24.rmSync(entry.path, { recursive: true, force: true });
   } catch (err) {
     process.stderr.write(`  ! rm ${entry.path}: ${err instanceof Error ? err.message : String(err)}
 `);
     return false;
   }
-  return !fs23.existsSync(entry.path);
+  return !fs24.existsSync(entry.path);
 }
 function collectWorktrees(worldsDir) {
   const out = /* @__PURE__ */ new Map();
-  for (const id of fs23.readdirSync(worldsDir)) {
-    const child = path26.join(worldsDir, id, "olam");
-    const gitMarker = path26.join(child, ".git");
-    if (!fs23.existsSync(gitMarker)) continue;
+  for (const id of fs24.readdirSync(worldsDir)) {
+    const child = path27.join(worldsDir, id, "olam");
+    const gitMarker = path27.join(child, ".git");
+    if (!fs24.existsSync(gitMarker)) continue;
     const gitDir = resolveGitDirForWorktree(child);
     if (!gitDir) continue;
     const branch = readBranch(child);
@@ -15868,7 +15898,7 @@ function collectWorktrees(worldsDir) {
   return out;
 }
 function resolveGitDirForWorktree(worktreePath) {
-  const gitMarker = path26.join(worktreePath, ".git");
+  const gitMarker = path27.join(worktreePath, ".git");
   try {
     const top = execFileSync5("git", ["rev-parse", "--show-toplevel"], {
       cwd: worktreePath,
@@ -15882,7 +15912,7 @@ function resolveGitDirForWorktree(worktreePath) {
       stdio: "pipe"
     }).trim();
     if (!common) return top;
-    return path26.dirname(path26.resolve(worktreePath, common));
+    return path27.dirname(path27.resolve(worktreePath, common));
   } catch {
     return null;
   }
@@ -15925,7 +15955,7 @@ function countUnpushed(worktreePath) {
 }
 function safeStat(p) {
   try {
-    return fs23.statSync(p);
+    return fs24.statSync(p);
   } catch {
     return null;
   }
@@ -15937,7 +15967,7 @@ function computeBytes(p) {
     const cur = stack.pop();
     let st;
     try {
-      st = fs23.lstatSync(cur);
+      st = fs24.lstatSync(cur);
     } catch {
       continue;
     }
@@ -15945,11 +15975,11 @@ function computeBytes(p) {
     if (st.isDirectory()) {
       let entries;
       try {
-        entries = fs23.readdirSync(cur);
+        entries = fs24.readdirSync(cur);
       } catch {
         continue;
       }
-      for (const name of entries) stack.push(path26.join(cur, name));
+      for (const name of entries) stack.push(path27.join(cur, name));
     } else {
       total += st.size;
     }
@@ -16157,7 +16187,7 @@ init_context();
 init_output();
 init_exit_codes();
 init_world_paths();
-import * as fs24 from "node:fs";
+import * as fs25 from "node:fs";
 import "node:path";
 import ora6 from "ora";
 function registerCrystallize(program2, options = {}) {
@@ -16189,7 +16219,7 @@ function registerCrystallize(program2, options = {}) {
       return;
     }
     const thoughtDbPath = getWorldDbPath(world.workspacePath);
-    if (!fs24.existsSync(thoughtDbPath)) {
+    if (!fs25.existsSync(thoughtDbPath)) {
       printError(`No thoughts captured yet for "${worldId}". Run a dispatch first.`);
       process.exitCode = EXIT_GENERIC_ERROR;
       return;
@@ -17563,11 +17593,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 path28 = {
+var path29 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep = defaultPlatform === "win32" ? path28.win32.sep : path28.posix.sep;
+var sep = defaultPlatform === "win32" ? path29.win32.sep : path29.posix.sep;
 minimatch.sep = sep;
 var GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
@@ -18395,23 +18425,23 @@ function registerPolicyCheck(program2) {
 // src/commands/upgrade.ts
 init_output();
 init_host_cp();
-import * as fs27 from "node:fs";
-import * as path31 from "node:path";
+import * as fs28 from "node:fs";
+import * as path32 from "node:path";
 import { spawnSync as spawnSync11 } from "node:child_process";
 import ora7 from "ora";
 import pc17 from "picocolors";
 
 // src/commands/upgrade-lock.ts
-import * as fs25 from "node:fs";
+import * as fs26 from "node:fs";
 import * as os15 from "node:os";
-import * as path29 from "node:path";
+import * as path30 from "node:path";
 import { spawnSync as spawnSync10 } from "node:child_process";
-var LOCK_FILE_PATH = path29.join(os15.homedir(), ".olam", ".upgrade.lock");
+var LOCK_FILE_PATH = path30.join(os15.homedir(), ".olam", ".upgrade.lock");
 var STALE_LOCK_TIMEOUT_MS = 5 * 60 * 1e3;
 function readLockFile(lockPath) {
   try {
-    if (!fs25.existsSync(lockPath)) return null;
-    const raw = fs25.readFileSync(lockPath, "utf-8").trim();
+    if (!fs26.existsSync(lockPath)) return null;
+    const raw = fs26.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;
@@ -18456,16 +18486,16 @@ function isStaleLock(content, nowMs = Date.now()) {
   return false;
 }
 function acquireLock(lockPath = LOCK_FILE_PATH, nowMs = Date.now()) {
-  const dir = path29.dirname(lockPath);
-  fs25.mkdirSync(dir, { recursive: true });
+  const dir = path30.dirname(lockPath);
+  fs26.mkdirSync(dir, { recursive: true });
   for (let attempt = 0; attempt < 2; attempt++) {
     try {
-      const fd = fs25.openSync(lockPath, "wx", 420);
+      const fd = fs26.openSync(lockPath, "wx", 420);
       try {
         const content = { pid: process.pid, startTs: nowMs };
-        fs25.writeSync(fd, JSON.stringify(content));
+        fs26.writeSync(fd, JSON.stringify(content));
       } finally {
-        fs25.closeSync(fd);
+        fs26.closeSync(fd);
       }
       return { acquired: true, lockPath };
     } catch (err) {
@@ -18474,7 +18504,7 @@ function acquireLock(lockPath = LOCK_FILE_PATH, nowMs = Date.now()) {
       const existing2 = readLockFile(lockPath);
       if (isStaleLock(existing2, nowMs)) {
         try {
-          fs25.unlinkSync(lockPath);
+          fs26.unlinkSync(lockPath);
         } catch (unlinkErr) {
           const ucode = unlinkErr.code;
           if (ucode !== "ENOENT") throw unlinkErr;
@@ -18499,7 +18529,7 @@ function acquireLock(lockPath = LOCK_FILE_PATH, nowMs = Date.now()) {
 }
 function releaseLock(lockPath = LOCK_FILE_PATH) {
   try {
-    fs25.unlinkSync(lockPath);
+    fs26.unlinkSync(lockPath);
   } catch (err) {
     const code = err.code;
     if (code !== "ENOENT") throw err;
@@ -18517,19 +18547,19 @@ function formatRefusalMessage(result, lockPath = LOCK_FILE_PATH) {
 }
 
 // src/commands/upgrade-log.ts
-import * as fs26 from "node:fs";
+import * as fs27 from "node:fs";
 import * as os16 from "node:os";
-import * as path30 from "node:path";
+import * as path31 from "node:path";
 function getUpgradeLogPath() {
   const home = process.env["HOME"] ?? os16.homedir();
-  return path30.join(home, ".olam", "upgrade.log");
+  return path31.join(home, ".olam", "upgrade.log");
 }
 var UPGRADE_LOG_PATH = getUpgradeLogPath();
 function appendUpgradeLog(row, logPath = getUpgradeLogPath()) {
   try {
-    fs26.mkdirSync(path30.dirname(logPath), { recursive: true });
+    fs27.mkdirSync(path31.dirname(logPath), { recursive: true });
     const line = JSON.stringify(row) + "\n";
-    fs26.appendFileSync(logPath, line, { mode: 420 });
+    fs27.appendFileSync(logPath, line, { mode: 420 });
   } catch (err) {
     process.stderr.write(
       `[upgrade-log] failed to append: ${err instanceof Error ? err.message : String(err)}
@@ -18538,10 +18568,10 @@ function appendUpgradeLog(row, logPath = getUpgradeLogPath()) {
   }
 }
 function readUpgradeLog(limit = 10, logPath = getUpgradeLogPath()) {
-  if (!fs26.existsSync(logPath)) return [];
+  if (!fs27.existsSync(logPath)) return [];
   let raw;
   try {
-    raw = fs26.readFileSync(logPath, "utf-8");
+    raw = fs27.readFileSync(logPath, "utf-8");
   } catch (err) {
     process.stderr.write(
       `[upgrade-log] failed to read: ${err instanceof Error ? err.message : String(err)}
@@ -18634,12 +18664,12 @@ init_protocol_version();
 init_install_root();
 var AUTH_HEALTH_URL2 = "http://127.0.0.1:9999/health";
 function isNodeModulesInSync(cwd) {
-  const lockPath = path31.join(cwd, "package-lock.json");
-  const markerPath = path31.join(cwd, "node_modules", ".package-lock.json");
-  if (!fs27.existsSync(lockPath) || !fs27.existsSync(markerPath)) return false;
+  const lockPath = path32.join(cwd, "package-lock.json");
+  const markerPath = path32.join(cwd, "node_modules", ".package-lock.json");
+  if (!fs28.existsSync(lockPath) || !fs28.existsSync(markerPath)) return false;
   try {
-    const lockStat = fs27.statSync(lockPath);
-    const markerStat = fs27.statSync(markerPath);
+    const lockStat = fs28.statSync(lockPath);
+    const markerStat = fs28.statSync(markerPath);
     return markerStat.mtimeMs >= lockStat.mtimeMs;
   } catch {
     return false;
@@ -18655,8 +18685,8 @@ function shouldSkipInstall(opts, cwd) {
   return { skip: false };
 }
 function validateRepoRoot(cwd) {
-  const marker = path31.join(cwd, "packages/host-cp/compose.yaml");
-  if (!fs27.existsSync(marker)) {
+  const marker = path32.join(cwd, "packages/host-cp/compose.yaml");
+  if (!fs28.existsSync(marker)) {
     return {
       ok: false,
       error: `Not an olam repo root (expected ${marker}).
@@ -19012,9 +19042,9 @@ async function recreateAuthService() {
   }
 }
 function readBundleHash(cwd) {
-  const indexPath = path31.join(cwd, "packages/control-plane/public/index.html");
-  if (!fs27.existsSync(indexPath)) return null;
-  return extractBundleHash(fs27.readFileSync(indexPath, "utf-8"));
+  const indexPath = path32.join(cwd, "packages/control-plane/public/index.html");
+  if (!fs28.existsSync(indexPath)) return null;
+  return extractBundleHash(fs28.readFileSync(indexPath, "utf-8"));
 }
 async function runUpgradePullByDigest(deps = {}) {
   const docker2 = deps.docker ?? realDocker;
@@ -19514,7 +19544,7 @@ ${buildResult.stderr}`);
     return;
   }
   const authSecret = readAuthSecret2();
-  const spaDir = path31.join(cwd, "packages/control-plane/app");
+  const spaDir = path32.join(cwd, "packages/control-plane/app");
   const spaResult = runStep2(
     "vite build (SPA)",
     "npx",
@@ -20048,20 +20078,20 @@ ${pc19.dim(`world: ${worldId}  sort: ${sortKey}  refresh: 5s  Ctrl-C to exit`)}
 
 // src/commands/keys.ts
 init_output();
-import * as fs28 from "node:fs";
+import * as fs29 from "node:fs";
 import * as os17 from "node:os";
-import * as path32 from "node:path";
+import * as path33 from "node:path";
 import YAML4 from "yaml";
 function olamHome2() {
-  return process.env.OLAM_HOME ?? path32.join(os17.homedir(), ".olam");
+  return process.env.OLAM_HOME ?? path33.join(os17.homedir(), ".olam");
 }
 function keysFilePath() {
-  return path32.join(olamHome2(), "keys.yaml");
+  return path33.join(olamHome2(), "keys.yaml");
 }
 function readKeysFile() {
   const filePath = keysFilePath();
-  if (!fs28.existsSync(filePath)) return null;
-  const raw = fs28.readFileSync(filePath, "utf-8").trim();
+  if (!fs29.existsSync(filePath)) return null;
+  const raw = fs29.readFileSync(filePath, "utf-8").trim();
   if (raw.length === 0) return null;
   try {
     const parsed = YAML4.parse(raw);
@@ -20077,13 +20107,13 @@ function readKeysFile() {
 }
 function writeKeysFile(keys) {
   const dir = olamHome2();
-  if (!fs28.existsSync(dir)) {
-    fs28.mkdirSync(dir, { recursive: true });
+  if (!fs29.existsSync(dir)) {
+    fs29.mkdirSync(dir, { recursive: true });
   }
   const filePath = keysFilePath();
   const content = YAML4.stringify(keys);
-  fs28.writeFileSync(filePath, content, { encoding: "utf-8", mode: 384 });
-  fs28.chmodSync(filePath, 384);
+  fs29.writeFileSync(filePath, content, { encoding: "utf-8", mode: 384 });
+  fs29.chmodSync(filePath, 384);
 }
 function redact(value) {
   if (value.length <= 8) return value + "...";
@@ -20126,7 +20156,7 @@ function registerKeys(program2) {
       }
       const { [key]: _removed, ...rest } = existing;
       if (Object.keys(rest).length === 0) {
-        fs28.unlinkSync(keysFilePath());
+        fs29.unlinkSync(keysFilePath());
       } else {
         writeKeysFile(rest);
       }
@@ -20149,26 +20179,26 @@ function registerKeys(program2) {
 }
 
 // src/commands/world-snapshot.ts
-import * as fs30 from "node:fs";
-import * as path34 from "node:path";
+import * as fs31 from "node:fs";
+import * as path35 from "node:path";
 import { execSync as execSync9 } from "node:child_process";
 import pc20 from "picocolors";
 
 // ../core/dist/world/snapshot.js
 import * as crypto6 from "node:crypto";
-import * as fs29 from "node:fs";
+import * as fs30 from "node:fs";
 import * as os18 from "node:os";
-import * as path33 from "node:path";
+import * as path34 from "node:path";
 import { execFileSync as execFileSync6 } from "node:child_process";
 function snapshotsDir() {
-  return process.env["OLAM_SNAPSHOTS_DIR"] ?? path33.join(os18.homedir(), ".olam", "snapshots");
+  return process.env["OLAM_SNAPSHOTS_DIR"] ?? path34.join(os18.homedir(), ".olam", "snapshots");
 }
 function snapshotKindDir(worldId, kind) {
-  return path33.join(snapshotsDir(), worldId, kind);
+  return path34.join(snapshotsDir(), worldId, kind);
 }
 function snapshotTarPath(worldId, kind, repoName, hash) {
   const base = repoName ? `${repoName}-${hash}` : hash;
-  return path33.join(snapshotKindDir(worldId, kind), `${base}.tar.gz`);
+  return path34.join(snapshotKindDir(worldId, kind), `${base}.tar.gz`);
 }
 function manifestPath(tarPath) {
   return tarPath.replace(/\.tar\.gz$/, ".manifest.json");
@@ -20185,17 +20215,17 @@ function hashBuffers(entries) {
   return hash.digest("hex").slice(0, 12);
 }
 function computeGemsFingerprint(repoDir) {
-  const lockfile = path33.join(repoDir, "Gemfile.lock");
-  if (!fs29.existsSync(lockfile))
+  const lockfile = path34.join(repoDir, "Gemfile.lock");
+  if (!fs30.existsSync(lockfile))
     return null;
-  return hashBuffers([{ path: "Gemfile.lock", content: fs29.readFileSync(lockfile) }]);
+  return hashBuffers([{ path: "Gemfile.lock", content: fs30.readFileSync(lockfile) }]);
 }
 function computeNodeFingerprint(repoDir) {
   const candidates = ["yarn.lock", "pnpm-lock.yaml", "package-lock.json"];
   for (const name of candidates) {
-    const lockfile = path33.join(repoDir, name);
-    if (fs29.existsSync(lockfile)) {
-      return hashBuffers([{ path: name, content: fs29.readFileSync(lockfile) }]);
+    const lockfile = path34.join(repoDir, name);
+    if (fs30.existsSync(lockfile)) {
+      return hashBuffers([{ path: name, content: fs30.readFileSync(lockfile) }]);
     }
   }
   return null;
@@ -20205,16 +20235,16 @@ function computePgFingerprint(repoDirs) {
   const entries = [];
   for (const repoDir of repoDirs) {
     for (const pattern of patterns) {
-      const filePath = path33.join(repoDir, pattern);
-      if (fs29.existsSync(filePath)) {
-        entries.push({ path: filePath, content: fs29.readFileSync(filePath) });
+      const filePath = path34.join(repoDir, pattern);
+      if (fs30.existsSync(filePath)) {
+        entries.push({ path: filePath, content: fs30.readFileSync(filePath) });
       }
     }
   }
   return entries.length > 0 ? hashBuffers(entries) : null;
 }
 function packTarball(srcDir, destPath, opts = {}) {
-  fs29.mkdirSync(path33.dirname(destPath), { recursive: true });
+  fs30.mkdirSync(path34.dirname(destPath), { recursive: true });
   const tmp = `${destPath}.tmp`;
   const args = [];
   if (opts.followSymlinks)
@@ -20222,47 +20252,47 @@ function packTarball(srcDir, destPath, opts = {}) {
   args.push("-czf", tmp, "-C", srcDir, ".");
   try {
     execFileSync6("tar", args, { stdio: "pipe" });
-    fs29.renameSync(tmp, destPath);
+    fs30.renameSync(tmp, destPath);
   } catch (err) {
     try {
-      fs29.rmSync(tmp, { force: true });
+      fs30.rmSync(tmp, { force: true });
     } catch {
     }
     throw err;
   }
 }
 function writeManifest(manifest, tarPath) {
-  fs29.writeFileSync(manifestPath(tarPath), JSON.stringify(manifest, null, 2), "utf-8");
+  fs30.writeFileSync(manifestPath(tarPath), JSON.stringify(manifest, null, 2), "utf-8");
 }
 function readManifest(tarPath) {
   const mPath = manifestPath(tarPath);
-  if (!fs29.existsSync(mPath))
+  if (!fs30.existsSync(mPath))
     return null;
   try {
-    return JSON.parse(fs29.readFileSync(mPath, "utf-8"));
+    return JSON.parse(fs30.readFileSync(mPath, "utf-8"));
   } catch {
     return null;
   }
 }
 function listSnapshots(worldIdFilter) {
   const root = snapshotsDir();
-  if (!fs29.existsSync(root))
+  if (!fs30.existsSync(root))
     return [];
   const now = Date.now();
   const results = [];
-  const worlds = worldIdFilter ? [worldIdFilter] : fs29.readdirSync(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  const worlds = worldIdFilter ? [worldIdFilter] : fs30.readdirSync(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   for (const worldId of worlds) {
-    const worldDir = path33.join(root, worldId);
-    if (!fs29.existsSync(worldDir) || !fs29.statSync(worldDir).isDirectory())
+    const worldDir = path34.join(root, worldId);
+    if (!fs30.existsSync(worldDir) || !fs30.statSync(worldDir).isDirectory())
       continue;
     for (const kind of ["gems", "node", "pg"]) {
-      const kindDir = path33.join(worldDir, kind);
-      if (!fs29.existsSync(kindDir))
+      const kindDir = path34.join(worldDir, kind);
+      if (!fs30.existsSync(kindDir))
         continue;
-      const tarballs = fs29.readdirSync(kindDir).filter((f) => f.endsWith(".tar.gz"));
+      const tarballs = fs30.readdirSync(kindDir).filter((f) => f.endsWith(".tar.gz"));
       for (const tarFile of tarballs) {
-        const tarPath = path33.join(kindDir, tarFile);
-        const stat = fs29.statSync(tarPath);
+        const tarPath = path34.join(kindDir, tarFile);
+        const stat = fs30.statSync(tarPath);
         const manifest = readManifest(tarPath);
         if (!manifest)
           continue;
@@ -20352,17 +20382,17 @@ function resolveKinds(arg) {
   return [];
 }
 async function captureGems(worldId, workspacePath, repo) {
-  const repoDir = path34.join(workspacePath, repo);
+  const repoDir = path35.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 = path34.join(repoDir, "vendor", "bundle");
-  if (fs30.existsSync(vendorBundle)) {
+  const vendorBundle = path35.join(repoDir, "vendor", "bundle");
+  if (fs31.existsSync(vendorBundle)) {
     try {
       packTarball(vendorBundle, tarPath);
-      const stat = fs30.statSync(tarPath);
+      const stat = fs31.statSync(tarPath);
       const manifest = {
         kind: "gems",
         worldId,
@@ -20395,10 +20425,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 }
     );
-    fs30.mkdirSync(path34.dirname(tarPath), { recursive: true });
+    fs31.mkdirSync(path35.dirname(tarPath), { recursive: true });
     execSync9(`docker cp ${containerName}:${tmpTar} "${tarPath}"`, { stdio: "pipe", timeout: 12e4 });
     execSync9(`docker exec ${containerName} rm -f ${tmpTar}`, { stdio: "pipe" });
-    const stat = fs30.statSync(tarPath);
+    const stat = fs31.statSync(tarPath);
     const manifest = {
       kind: "gems",
       worldId,
@@ -20415,19 +20445,19 @@ async function captureGems(worldId, workspacePath, repo) {
   }
 }
 async function captureNode(worldId, workspacePath, repo) {
-  const repoDir = path34.join(workspacePath, repo);
+  const repoDir = path35.join(workspacePath, repo);
   const fingerprint = computeNodeFingerprint(repoDir);
   if (!fingerprint) {
     return { ok: false, tarPath: "", msg: "no lockfile \u2014 layer does not apply" };
   }
-  const nodeModules = path34.join(repoDir, "node_modules");
-  if (!fs30.existsSync(nodeModules)) {
+  const nodeModules = path35.join(repoDir, "node_modules");
+  if (!fs31.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 = fs30.statSync(tarPath);
+    const stat = fs31.statSync(tarPath);
     const manifest = {
       kind: "node",
       worldId,
@@ -20444,7 +20474,7 @@ async function captureNode(worldId, workspacePath, repo) {
   }
 }
 async function capturePg(worldId, workspacePath, repoNames) {
-  const repoDirs = repoNames.map((r) => path34.join(workspacePath, r));
+  const repoDirs = repoNames.map((r) => path35.join(workspacePath, r));
   const fingerprint = computePgFingerprint(repoDirs);
   if (!fingerprint) {
     return { ok: false, tarPath: "", msg: "no Gemfile.lock / schema.rb \u2014 layer does not apply" };
@@ -20459,13 +20489,13 @@ async function capturePg(worldId, workspacePath, repoNames) {
   }
   try {
     execSync9(`docker stop ${containerName}`, { stdio: "pipe", timeout: 3e4 });
-    fs30.mkdirSync(path34.dirname(tarPath), { recursive: true });
+    fs31.mkdirSync(path35.dirname(tarPath), { recursive: true });
     execSync9(
-      `docker run --rm         -v "${volumeName2}:/pgdata:ro"         -v "${path34.dirname(tarPath)}:/dest"         alpine         sh -c 'tar -czf /dest/${path34.basename(tarPath)}.tmp -C /pgdata . && mv /dest/${path34.basename(tarPath)}.tmp /dest/${path34.basename(tarPath)}'`,
+      `docker run --rm         -v "${volumeName2}:/pgdata:ro"         -v "${path35.dirname(tarPath)}:/dest"         alpine         sh -c 'tar -czf /dest/${path35.basename(tarPath)}.tmp -C /pgdata . && mv /dest/${path35.basename(tarPath)}.tmp /dest/${path35.basename(tarPath)}'`,
       { stdio: "pipe", timeout: 18e4 }
     );
     execSync9(`docker start ${containerName}`, { stdio: "pipe", timeout: 3e4 });
-    const stat = fs30.statSync(tarPath);
+    const stat = fs31.statSync(tarPath);
     const manifest = {
       kind: "pg",
       worldId,
@@ -20540,35 +20570,35 @@ function formatAge2(ms) {
 // src/commands/refresh.ts
 init_context();
 init_output();
-import * as fs32 from "node:fs";
+import * as fs33 from "node:fs";
 import * as os19 from "node:os";
-import * as path36 from "node:path";
+import * as path37 from "node:path";
 import { spawnSync as spawnSync13 } from "node:child_process";
 import ora8 from "ora";
 
 // src/commands/refresh-helpers.ts
-import * as fs31 from "node:fs";
-import * as path35 from "node:path";
+import * as fs32 from "node:fs";
+import * as path36 from "node:path";
 function collectCpSourceFiles(standaloneDir) {
-  if (!fs31.existsSync(standaloneDir)) {
+  if (!fs32.existsSync(standaloneDir)) {
     throw new Error(`CP standalone dir not found: ${standaloneDir}`);
   }
   const entries = [];
-  const topLevel = fs31.readdirSync(standaloneDir).filter((f) => {
-    const stat = fs31.statSync(path35.join(standaloneDir, f));
+  const topLevel = fs32.readdirSync(standaloneDir).filter((f) => {
+    const stat = fs32.statSync(path36.join(standaloneDir, f));
     return stat.isFile() && f.endsWith(".mjs") && !f.endsWith(".test.mjs");
   }).sort();
   for (const f of topLevel) {
-    entries.push({ srcPath: path35.join(standaloneDir, f), destRelPath: f });
+    entries.push({ srcPath: path36.join(standaloneDir, f), destRelPath: f });
   }
-  const libDir = path35.join(standaloneDir, "lib");
-  if (fs31.existsSync(libDir) && fs31.statSync(libDir).isDirectory()) {
-    const libFiles = fs31.readdirSync(libDir).filter((f) => {
-      const stat = fs31.statSync(path35.join(libDir, f));
+  const libDir = path36.join(standaloneDir, "lib");
+  if (fs32.existsSync(libDir) && fs32.statSync(libDir).isDirectory()) {
+    const libFiles = fs32.readdirSync(libDir).filter((f) => {
+      const stat = fs32.statSync(path36.join(libDir, f));
       return stat.isFile() && f.endsWith(".mjs") && !f.endsWith(".test.mjs");
     }).sort();
     for (const f of libFiles) {
-      entries.push({ srcPath: path35.join(libDir, f), destRelPath: `lib/${f}` });
+      entries.push({ srcPath: path36.join(libDir, f), destRelPath: `lib/${f}` });
     }
   }
   return entries;
@@ -20626,16 +20656,16 @@ async function refreshWorld(worldId, portOffset, standaloneDir, opts) {
       error: err instanceof Error ? err.message : String(err)
     };
   }
-  const stagingDir = fs32.mkdtempSync(
-    path36.join(os19.tmpdir(), `olam-refresh-${worldId}-`)
+  const stagingDir = fs33.mkdtempSync(
+    path37.join(os19.tmpdir(), `olam-refresh-${worldId}-`)
   );
   try {
     const hasLib = entries.some((e) => e.destRelPath.startsWith("lib/"));
     if (hasLib) {
-      fs32.mkdirSync(path36.join(stagingDir, "lib"), { recursive: true });
+      fs33.mkdirSync(path37.join(stagingDir, "lib"), { recursive: true });
     }
     for (const { srcPath, destRelPath } of entries) {
-      fs32.copyFileSync(srcPath, path36.join(stagingDir, destRelPath));
+      fs33.copyFileSync(srcPath, path37.join(stagingDir, destRelPath));
     }
     const cpResult = docker([
       "cp",
@@ -20650,7 +20680,7 @@ async function refreshWorld(worldId, portOffset, standaloneDir, opts) {
       };
     }
   } finally {
-    fs32.rmSync(stagingDir, { recursive: true, force: true });
+    fs33.rmSync(stagingDir, { recursive: true, force: true });
   }
   if (opts.restart) {
     const restartResult = docker([
@@ -20687,11 +20717,11 @@ function registerRefresh(program2) {
       process.exitCode = 1;
       return;
     }
-    const standaloneDir = path36.join(
+    const standaloneDir = path37.join(
       process.cwd(),
       "packages/control-plane/standalone"
     );
-    if (!fs32.existsSync(standaloneDir)) {
+    if (!fs33.existsSync(standaloneDir)) {
       printError(
         `CP standalone source not found at ${standaloneDir}.
 Run \`olam refresh\` from the olam repo root.`
@@ -20770,9 +20800,9 @@ Run \`olam refresh\` from the olam repo root.`
 }
 
 // src/commands/diagnose.ts
-import * as fs33 from "node:fs";
+import * as fs34 from "node:fs";
 import * as os20 from "node:os";
-import * as path37 from "node:path";
+import * as path38 from "node:path";
 import { execFileSync as execFileSync7, execSync as execSync10 } from "node:child_process";
 import pc21 from "picocolors";
 
@@ -20807,9 +20837,9 @@ function stripSecrets(input) {
 }
 
 // src/commands/diagnose.ts
-var DIAGNOSTICS_DIR = path37.join(os20.homedir(), ".olam", "diagnostics");
-var LOG_DIR = path37.join(os20.homedir(), ".olam", "log");
-var CACHE_DIR = path37.join(os20.homedir(), ".olam", "cache");
+var DIAGNOSTICS_DIR = path38.join(os20.homedir(), ".olam", "diagnostics");
+var LOG_DIR = path38.join(os20.homedir(), ".olam", "log");
+var CACHE_DIR = path38.join(os20.homedir(), ".olam", "cache");
 var LOG_TAIL_LINES = 200;
 function safeExec(cmd) {
   try {
@@ -20823,10 +20853,10 @@ function defaultZip(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 = path37.join(_outDir, `olam-diag-${ts}.zip`);
-  const tmpDir = fs33.mkdtempSync(path37.join(os20.tmpdir(), "olam-diag-"));
+  const zipPath = path38.join(_outDir, `olam-diag-${ts}.zip`);
+  const tmpDir = fs34.mkdtempSync(path38.join(os20.tmpdir(), "olam-diag-"));
   try {
-    fs33.mkdirSync(_outDir, { recursive: true });
+    fs34.mkdirSync(_outDir, { recursive: true });
     const entries = [];
     const version = process.env["OLAM_CLI_VERSION"] ?? "unknown";
     const nodeVersion = process.version;
@@ -20842,14 +20872,14 @@ platform: ${platform}
       `uptime: ${os20.uptime()}s`
     ].join("\n") + "\n";
     _writeEntry(tmpDir, "os-info.txt", stripSecrets(osContent), entries);
-    const depsFile = path37.join(CACHE_DIR, "deps.json");
-    if (fs33.existsSync(depsFile)) {
-      const deps = fs33.readFileSync(depsFile, "utf-8");
+    const depsFile = path38.join(CACHE_DIR, "deps.json");
+    if (fs34.existsSync(depsFile)) {
+      const deps = fs34.readFileSync(depsFile, "utf-8");
       _writeEntry(tmpDir, "deps.json", stripSecrets(deps), entries);
     }
     const latestLog = _latestLog(_logDir);
     if (latestLog) {
-      const lines = fs33.readFileSync(latestLog, "utf-8").split("\n");
+      const lines = fs34.readFileSync(latestLog, "utf-8").split("\n");
       const tail = lines.slice(-LOG_TAIL_LINES).join("\n");
       _writeEntry(tmpDir, "log-tail.txt", stripSecrets(tail), entries);
     }
@@ -20861,38 +20891,38 @@ platform: ${platform}
     if (authAudit) {
       _writeEntry(tmpDir, "audit-auth-callers.txt", stripSecrets(authAudit), entries);
     }
-    const fileArgs = entries.map((e) => path37.join(tmpDir, e));
+    const fileArgs = entries.map((e) => path38.join(tmpDir, e));
     try {
       _zip(zipPath, fileArgs);
     } catch (err) {
       throw new Error(`zip command produced no output file. zip stderr: ${err.message}`);
     }
-    if (!fs33.existsSync(zipPath)) {
+    if (!fs34.existsSync(zipPath)) {
       throw new Error("zip command produced no output file.");
     }
     return { zipPath, entries };
   } finally {
     try {
-      fs33.rmSync(tmpDir, { recursive: true, force: true });
+      fs34.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
   }
 }
 function _writeEntry(dir, name, content, entries) {
-  fs33.writeFileSync(path37.join(dir, name), content, { mode: 420 });
+  fs34.writeFileSync(path38.join(dir, name), content, { mode: 420 });
   entries.push(name);
 }
 function _latestLog(logDir) {
-  if (!fs33.existsSync(logDir)) return null;
-  const files = fs33.readdirSync(logDir).filter((f) => f.startsWith("host-")).sort().reverse();
-  return files.length > 0 ? path37.join(logDir, files[0]) : null;
+  if (!fs34.existsSync(logDir)) return null;
+  const files = fs34.readdirSync(logDir).filter((f) => f.startsWith("host-")).sort().reverse();
+  return files.length > 0 ? path38.join(logDir, files[0]) : null;
 }
 async function buildTelemetryPayload() {
   const channel = "stable";
-  const manifestFile = path37.join(CACHE_DIR, "manifest.json");
+  const manifestFile = path38.join(CACHE_DIR, "manifest.json");
   let manifestAgeHours = null;
-  if (fs33.existsSync(manifestFile)) {
-    const mtime = fs33.statSync(manifestFile).mtime.getTime();
+  if (fs34.existsSync(manifestFile)) {
+    const mtime = fs34.statSync(manifestFile).mtime.getTime();
     manifestAgeHours = Math.round((Date.now() - mtime) / 36e5);
   }
   return {
@@ -20935,24 +20965,24 @@ function registerDiagnose(program2) {
 }
 
 // src/commands/update.ts
-import * as fs36 from "node:fs";
+import * as fs37 from "node:fs";
 import * as os22 from "node:os";
-import * as path40 from "node:path";
+import * as path41 from "node:path";
 import { execSync as execSync11 } from "node:child_process";
 import pc22 from "picocolors";
 
 // src/lib/symlink-reconcile.ts
-import * as fs34 from "node:fs";
-import * as path38 from "node:path";
+import * as fs35 from "node:fs";
+import * as path39 from "node:path";
 var realFs = {
-  readdirSync: (p) => fs34.readdirSync(p),
-  existsSync: (p) => fs34.existsSync(p),
-  lstatSync: (p) => fs34.lstatSync(p),
-  readlinkSync: (p) => fs34.readlinkSync(p),
-  symlinkSync: (t, l) => fs34.symlinkSync(t, l),
-  unlinkSync: (p) => fs34.unlinkSync(p),
+  readdirSync: (p) => fs35.readdirSync(p),
+  existsSync: (p) => fs35.existsSync(p),
+  lstatSync: (p) => fs35.lstatSync(p),
+  readlinkSync: (p) => fs35.readlinkSync(p),
+  symlinkSync: (t, l) => fs35.symlinkSync(t, l),
+  unlinkSync: (p) => fs35.unlinkSync(p),
   mkdirSync: (p, o) => {
-    fs34.mkdirSync(p, o);
+    fs35.mkdirSync(p, o);
   }
 };
 function reconcileSkillSymlinks(npmSkillsDir, claudeSkillsDir, _fs = realFs) {
@@ -20962,8 +20992,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 = path38.join(claudeSkillsDir, skill);
-    const target = path38.join(npmSkillsDir, skill);
+    const linkPath = path39.join(claudeSkillsDir, skill);
+    const target = path39.join(npmSkillsDir, skill);
     if (!_fs.existsSync(linkPath)) {
       try {
         _fs.symlinkSync(target, linkPath);
@@ -20976,7 +21006,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 = path38.join(claudeSkillsDir, entry);
+    const linkPath = path39.join(claudeSkillsDir, entry);
     let isSymlink = false;
     try {
       isSymlink = _fs.lstatSync(linkPath).isSymbolicLink();
@@ -21001,9 +21031,9 @@ function reconcileSkillSymlinks(npmSkillsDir, claudeSkillsDir, _fs = realFs) {
 
 // src/commands/update.ts
 var PACKAGE_NAME = "@pleri/olam-cli";
-var CACHE_DIR2 = path40.join(os22.homedir(), ".olam", "cache");
-var LOG_DIR2 = path40.join(os22.homedir(), ".olam", "log");
-var LAST_STABLE_FILE = path40.join(CACHE_DIR2, "last-stable.txt");
+var CACHE_DIR2 = path41.join(os22.homedir(), ".olam", "cache");
+var LOG_DIR2 = path41.join(os22.homedir(), ".olam", "log");
+var LAST_STABLE_FILE = path41.join(CACHE_DIR2, "last-stable.txt");
 function defaultExec(cmd) {
   try {
     const stdout = execSync11(cmd, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
@@ -21025,22 +21055,22 @@ function getCurrentVersion(_exec = defaultExec) {
 }
 function readLastStable(file = LAST_STABLE_FILE) {
   try {
-    const v = fs36.readFileSync(file, "utf-8").trim();
+    const v = fs37.readFileSync(file, "utf-8").trim();
     return v || null;
   } catch {
     return null;
   }
 }
 function writeLastStable(version, file = LAST_STABLE_FILE) {
-  fs36.mkdirSync(path40.dirname(file), { recursive: true });
-  fs36.writeFileSync(file, version, { mode: 420 });
+  fs37.mkdirSync(path41.dirname(file), { recursive: true });
+  fs37.writeFileSync(file, version, { mode: 420 });
 }
 function logUpdateFailure(stderr) {
   const ts = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
-  const logFile = path40.join(LOG_DIR2, `update-${ts}.log`);
+  const logFile = path41.join(LOG_DIR2, `update-${ts}.log`);
   try {
-    fs36.mkdirSync(LOG_DIR2, { recursive: true });
-    fs36.appendFileSync(logFile, `[update-failure ${(/* @__PURE__ */ new Date()).toISOString()}]
+    fs37.mkdirSync(LOG_DIR2, { recursive: true });
+    fs37.appendFileSync(logFile, `[update-failure ${(/* @__PURE__ */ new Date()).toISOString()}]
 ${stderr}
 `, "utf-8");
   } catch {
@@ -21127,8 +21157,8 @@ async function doUpdate(opts, _exec = defaultExec, _reconcile = reconcileSkillSy
   let symlinkResult = { added: [], removed: [] };
   if (npmRootResult.exitCode === 0) {
     const npmRoot = npmRootResult.stdout.trim();
-    const npmSkillsDir = path40.join(npmRoot, "@pleri", "olam-cli", "plugin", "skills");
-    const claudeSkillsDir = path40.join(os22.homedir(), ".claude", "skills");
+    const npmSkillsDir = path41.join(npmRoot, "@pleri", "olam-cli", "plugin", "skills");
+    const claudeSkillsDir = path41.join(os22.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)) {
@@ -21174,8 +21204,8 @@ async function doRollback(_exec = defaultExec, _reconcile = reconcileSkillSymlin
   if (npmRootResult.exitCode === 0) {
     const npmRoot = npmRootResult.stdout.trim();
     _reconcile(
-      path40.join(npmRoot, "@pleri", "olam-cli", "plugin", "skills"),
-      path40.join(os22.homedir(), ".claude", "skills")
+      path41.join(npmRoot, "@pleri", "olam-cli", "plugin", "skills"),
+      path41.join(os22.homedir(), ".claude", "skills")
     );
   }
   return { action: "rolled-back", restoredVersion: prev, exitCode: 0 };
@@ -21256,7 +21286,7 @@ function registerBegin(program2) {
 }
 
 // src/commands/config.ts
-import * as fs39 from "node:fs";
+import * as fs40 from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 
 // ../core/dist/global-config/schema.js
@@ -21333,9 +21363,9 @@ var DEFAULT_GLOBAL_CONFIG = {
 };
 
 // ../core/dist/global-config/store.js
-import * as fs37 from "node:fs";
+import * as fs38 from "node:fs";
 import * as os23 from "node:os";
-import * as path41 from "node:path";
+import * as path42 from "node:path";
 var GlobalConfigReadError = class extends Error {
   constructor(configPath, cause) {
     const msg = cause instanceof Error ? cause.message : String(cause);
@@ -21348,16 +21378,16 @@ function globalConfigPath() {
   const override = process.env["OLAM_GLOBAL_CONFIG_PATH"];
   if (override && override.length > 0)
     return override;
-  return path41.join(os23.homedir(), ".olam", "config.json");
+  return path42.join(os23.homedir(), ".olam", "config.json");
 }
 function readGlobalConfig() {
   const configPath = globalConfigPath();
-  if (!fs37.existsSync(configPath)) {
+  if (!fs38.existsSync(configPath)) {
     return { ...DEFAULT_GLOBAL_CONFIG };
   }
   let raw;
   try {
-    raw = fs37.readFileSync(configPath, "utf-8");
+    raw = fs38.readFileSync(configPath, "utf-8");
   } catch (err) {
     throw new GlobalConfigReadError(configPath, err);
   }
@@ -21376,20 +21406,20 @@ function readGlobalConfig() {
 function writeGlobalConfig(config) {
   const configPath = globalConfigPath();
   const validated = GlobalConfigSchema.parse(config);
-  const dir = path41.dirname(configPath);
-  fs37.mkdirSync(dir, { recursive: true });
+  const dir = path42.dirname(configPath);
+  fs38.mkdirSync(dir, { recursive: true });
   const tmp = `${configPath}.tmp-${process.pid}`;
-  fs37.writeFileSync(tmp, JSON.stringify(validated, null, 2) + "\n", { mode: 420 });
-  fs37.renameSync(tmp, configPath);
+  fs38.writeFileSync(tmp, JSON.stringify(validated, null, 2) + "\n", { mode: 420 });
+  fs38.renameSync(tmp, configPath);
 }
 
 // ../core/dist/global-config/repos.js
-import * as fs38 from "node:fs";
+import * as fs39 from "node:fs";
 import * as os24 from "node:os";
-import * as path42 from "node:path";
+import * as path43 from "node:path";
 function expandPath(p) {
   if (p === "~" || p.startsWith("~/")) {
-    return path42.join(os24.homedir(), p.slice(1));
+    return path43.join(os24.homedir(), p.slice(1));
   }
   return p;
 }
@@ -21402,7 +21432,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 (!fs38.existsSync(resolvedPath)) {
+  if (!fs39.existsSync(resolvedPath)) {
     throw new Error(`path "${entry.path}" does not exist. Verify the path is correct.`);
   }
   const now = Date.now();
@@ -21431,7 +21461,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 && !fs38.existsSync(resolvedUpdatePath)) {
+  if (resolvedUpdatePath !== void 0 && !fs39.existsSync(resolvedUpdatePath)) {
     throw new Error(`path "${updates.path}" does not exist. Verify the path is correct.`);
   }
   const existing = config.repos[idx];
@@ -21455,14 +21485,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 (!fs39.existsSync(resolvedPath)) {
+    if (!fs40.existsSync(resolvedPath)) {
       process.stderr.write(`config file not found: ${resolvedPath}
 `);
       process.exit(1);
     }
     let raw;
     try {
-      raw = fs39.readFileSync(resolvedPath, "utf-8");
+      raw = fs40.readFileSync(resolvedPath, "utf-8");
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       process.stderr.write(`cannot read ${resolvedPath}: ${msg}
@@ -21899,12 +21929,12 @@ import * as readline3 from "node:readline";
 import pc27 from "picocolors";
 
 // src/commands/mcp/import-discovery.ts
-import * as fs40 from "node:fs";
+import * as fs41 from "node:fs";
 import * as os25 from "node:os";
-import * as path43 from "node:path";
+import * as path44 from "node:path";
 function readJsonFile(filePath) {
   try {
-    const raw = fs40.readFileSync(filePath, "utf-8");
+    const raw = fs41.readFileSync(filePath, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -21933,24 +21963,24 @@ function extractMcpServers(obj, source, sourceLabel) {
 }
 function getClaudeDesktopPath() {
   if (process.platform === "darwin") {
-    return path43.join(os25.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    return path44.join(os25.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
   }
   if (process.platform === "win32") {
-    const appData = process.env["APPDATA"] ?? path43.join(os25.homedir(), "AppData", "Roaming");
-    return path43.join(appData, "Claude", "claude_desktop_config.json");
+    const appData = process.env["APPDATA"] ?? path44.join(os25.homedir(), "AppData", "Roaming");
+    return path44.join(appData, "Claude", "claude_desktop_config.json");
   }
-  return path43.join(os25.homedir(), ".config", "Claude", "claude_desktop_config.json");
+  return path44.join(os25.homedir(), ".config", "Claude", "claude_desktop_config.json");
 }
 function getOlamRepoPaths() {
   const configPaths = [
-    path43.join(os25.homedir(), ".olam", "config.yaml"),
-    path43.join(process.cwd(), ".olam", "config.yaml")
+    path44.join(os25.homedir(), ".olam", "config.yaml"),
+    path44.join(process.cwd(), ".olam", "config.yaml")
   ];
   const paths = [];
   for (const configPath of configPaths) {
-    if (!fs40.existsSync(configPath)) continue;
+    if (!fs41.existsSync(configPath)) continue;
     try {
-      const raw = fs40.readFileSync(configPath, "utf-8");
+      const raw = fs41.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]);
@@ -21966,7 +21996,7 @@ async function discoverMcpSources(repoPaths) {
   const sources = [];
   const sourceDefs = [
     {
-      path: path43.join(os25.homedir(), ".claude.json"),
+      path: path44.join(os25.homedir(), ".claude.json"),
       label: "Claude Code (~/.claude.json)"
     },
     {
@@ -21974,19 +22004,19 @@ async function discoverMcpSources(repoPaths) {
       label: "Claude Desktop"
     },
     {
-      path: path43.join(os25.homedir(), ".cursor", "mcp.json"),
+      path: path44.join(os25.homedir(), ".cursor", "mcp.json"),
       label: "Cursor (~/.cursor/mcp.json)"
     },
     {
-      path: path43.join(os25.homedir(), ".codeium", "windsurf", "mcp_config.json"),
+      path: path44.join(os25.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: path43.join(repoPath, ".mcp.json"),
-      label: `.mcp.json (${path43.basename(repoPath)})`
+      path: path44.join(repoPath, ".mcp.json"),
+      label: `.mcp.json (${path44.basename(repoPath)})`
     });
   }
   const reads = await Promise.all(
@@ -22216,18 +22246,18 @@ function registerMcp(program2) {
 }
 
 // src/pleri-config.ts
-import * as fs41 from "node:fs";
-import * as path44 from "node:path";
+import * as fs42 from "node:fs";
+import * as path45 from "node:path";
 function isPleriConfigured(configDir = process.env.OLAM_CONFIG_DIR ?? ".olam") {
   if (process.env.PLERI_BASE_URL) {
     return true;
   }
-  const configPath = path44.join(configDir, "config.yaml");
-  if (!fs41.existsSync(configPath)) {
+  const configPath = path45.join(configDir, "config.yaml");
+  if (!fs42.existsSync(configPath)) {
     return false;
   }
   try {
-    const contents = fs41.readFileSync(configPath, "utf8");
+    const contents = fs42.readFileSync(configPath, "utf8");
     return /^[^#\n]*\bpleri:/m.test(contents);
   } catch {
     return false;
@@ -22236,23 +22266,6 @@ function isPleriConfigured(configDir = process.env.OLAM_CONFIG_DIR ?? ".olam") {
 
 // src/index.ts
 var program = new Command();
-function readCliVersion() {
-  try {
-    const here = path45.dirname(fileURLToPath4(import.meta.url));
-    for (const candidate of [
-      path45.join(here, "package.json"),
-      path45.join(here, "..", "package.json"),
-      path45.join(here, "..", "..", "package.json")
-    ]) {
-      if (fs42.existsSync(candidate)) {
-        const pkg = JSON.parse(fs42.readFileSync(candidate, "utf-8"));
-        if (typeof pkg.version === "string" && pkg.version.length > 0) return pkg.version;
-      }
-    }
-  } catch {
-  }
-  return "0.0.0-unknown";
-}
 program.name("olam").description("Olam \u2014 isolated development worlds with thought graph capture").version(readCliVersion());
 registerInit(program);
 registerInstall(program);