@pleri/olam-cli 0.1.68 → 0.1.70

package/dist/mcp-server.js

@@ -3228,8 +3228,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path23) {
-      let input = path23;
+    function removeDotSegments(path24) {
+      let input = path24;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3428,8 +3428,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path23, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path23 && path23 !== "/" ? path23 : void 0;
+        const [path24, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path24 && path24 !== "/" ? path24 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -6791,12 +6791,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs19, exportName) {
+    function addFormats(ajv, list, fs20, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs19[f]);
+        ajv.addFormat(f, fs20[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -7002,10 +7002,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path23) {
-  if (!path23)
+function getElementAtPath(obj, path24) {
+  if (!path24)
     return obj;
-  return path23.reduce((acc, key) => acc?.[key], obj);
+  return path24.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -7325,11 +7325,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path23, issues) {
+function prefixIssues(path24, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path23);
+    iss.path.unshift(path24);
     return iss;
   });
 }
@@ -13403,8 +13403,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path23, errorMaps, issueData } = params;
-  const fullPath = [...path23, ...issueData.path || []];
+  const { data, path: path24, errorMaps, issueData } = params;
+  const fullPath = [...path24, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -13520,11 +13520,11 @@ var errorUtil;
 
 // ../../node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path23, key) {
+  constructor(parent, value, path24, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path23;
+    this._path = path24;
     this._key = key;
   }
   get path() {
@@ -21365,8 +21365,8 @@ var AuthClient = class {
       throw new Error(`failed to report rate-limit for ${accountId} (HTTP ${res.status})`);
     }
   }
-  async request(method, path23, body, attempt = 0) {
-    const url = `${this.baseUrl}${path23}`;
+  async request(method, path24, body, attempt = 0) {
+    const url = `${this.baseUrl}${path24}`;
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.timeoutMs);
     const headers = {};
@@ -21384,7 +21384,7 @@ var AuthClient = class {
     } catch (err) {
       if (attempt < RETRY_COUNT && isTransient(err)) {
         await sleep(RETRY_BACKOFF_MS * (attempt + 1));
-        return this.request(method, path23, body, attempt + 1);
+        return this.request(method, path24, body, attempt + 1);
       }
       throw err;
     } finally {
@@ -22191,12 +22191,12 @@ function register3(server, _ctx, _initError) {
         registry2.close();
       }
       try {
-        const { default: fs19 } = await import("node:fs");
-        const { default: os12 } = await import("node:os");
-        const { default: path23 } = await import("node:path");
-        const tokenPath = path23.join(os12.homedir(), ".olam", "host-cp.token");
-        if (fs19.existsSync(tokenPath)) {
-          const token = fs19.readFileSync(tokenPath, "utf-8").trim();
+        const { default: fs20 } = await import("node:fs");
+        const { default: os13 } = await import("node:os");
+        const { default: path24 } = await import("node:path");
+        const tokenPath = path24.join(os13.homedir(), ".olam", "host-cp.token");
+        if (fs20.existsSync(tokenPath)) {
+          const token = fs20.readFileSync(tokenPath, "utf-8").trim();
           await fetch("http://127.0.0.1:19000/api/admin/world-pr", {
             method: "POST",
             headers: { "Content-Type": "application/json", Authorization: `Bearer ${token}` },
@@ -22389,7 +22389,7 @@ var KNOWN_TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
   "deploy"
 ]);
 var FORBIDDEN_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
-function refineForbiddenKeys(value, path23, ctx, rejectSource) {
+function refineForbiddenKeys(value, path24, ctx, rejectSource) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return;
   }
@@ -22397,12 +22397,12 @@ function refineForbiddenKeys(value, path23, ctx, rejectSource) {
     if (FORBIDDEN_KEYS.has(key)) {
       ctx.addIssue({
         code: external_exports.ZodIssueCode.custom,
-        path: [...path23, key],
+        path: [...path24, key],
         message: `forbidden key "${key}" (prototype-pollution surface)`
       });
       continue;
     }
-    if (rejectSource && path23.length === 0 && key === "source") {
+    if (rejectSource && path24.length === 0 && key === "source") {
       ctx.addIssue({
         code: external_exports.ZodIssueCode.custom,
         path: ["source"],
@@ -22410,21 +22410,21 @@ function refineForbiddenKeys(value, path23, ctx, rejectSource) {
       });
       continue;
     }
-    refineForbiddenKeys(value[key], [...path23, key], ctx, false);
+    refineForbiddenKeys(value[key], [...path24, key], ctx, false);
   }
 }
-function rejectForbiddenKeys(value, path23, rejectSource) {
+function rejectForbiddenKeys(value, path24, rejectSource) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return;
   }
   for (const key of Object.keys(value)) {
     if (FORBIDDEN_KEYS.has(key)) {
-      throw new Error(`[manifest] ${path23}: forbidden key "${key}" (prototype-pollution surface)`);
+      throw new Error(`[manifest] ${path24}: forbidden key "${key}" (prototype-pollution surface)`);
     }
     if (rejectSource && key === "source") {
-      throw new Error(`[manifest] ${path23}: top-level "source" is loader-stamped \u2014 manifests must not author it`);
+      throw new Error(`[manifest] ${path24}: top-level "source" is loader-stamped \u2014 manifests must not author it`);
     }
-    rejectForbiddenKeys(value[key], `${path23}.${key}`, false);
+    rejectForbiddenKeys(value[key], `${path24}.${key}`, false);
   }
 }
 function unknownTopLevelKeys(parsed) {
@@ -22862,10 +22862,10 @@ function extractMcpConfig(claudeJsonPath) {
   }
   return { mcpServers, secrets };
 }
-function readOptional(path23) {
-  if (!existsSync6(path23)) return null;
+function readOptional(path24) {
+  if (!existsSync6(path24)) return null;
   try {
-    return readFileSync5(path23, "utf8");
+    return readFileSync5(path24, "utf8");
   } catch {
     return null;
   }
@@ -24008,8 +24008,8 @@ var CloudflareProvider = class extends ComputeProvider {
   // -----------------------------------------------------------------------
   // Internal fetch helper
   // -----------------------------------------------------------------------
-  async request(path23, method, body) {
-    const url = `${this.config.workerUrl}${path23}`;
+  async request(path24, method, body) {
+    const url = `${this.config.workerUrl}${path24}`;
     const bearer = await this.config.mintToken();
     const headers = {
       Authorization: `Bearer ${bearer}`
@@ -26442,10 +26442,10 @@ async function writeManifest(args) {
     capturedAt: args.capturedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
     shots: entries
   };
-  const path23 = join12(args.outDir, "manifest.json");
-  await writeFile(path23, `${JSON.stringify(manifest, null, 2)}
+  const path24 = join12(args.outDir, "manifest.json");
+  await writeFile(path24, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
-  return { path: path23, manifest };
+  return { path: path24, manifest };
 }
 
 // ../mcp-server/src/tools/_capture/proxy.ts
@@ -26699,9 +26699,9 @@ async function startProxy(opts) {
       const liveCompiled = verified.allowedPaths.map(compileGlob);
       const target = parseRequestTarget(req);
       if (!target) return httpReject(400, "invalid_target");
-      const path23 = target.pathname;
-      if (!liveCompiled.some((re) => re.test(path23))) {
-        return httpReject(403, "outside_allow_list", { path: path23 });
+      const path24 = target.pathname;
+      if (!liveCompiled.some((re) => re.test(path24))) {
+        return httpReject(403, "outside_allow_list", { path: path24 });
       }
       const headerWorld = req.headers[WORLD_ASSERT_HEADER];
       const headerWorldStr = typeof headerWorld === "string" ? headerWorld : Array.isArray(headerWorld) && headerWorld.length > 0 ? headerWorld[0] : void 0;
@@ -27480,14 +27480,14 @@ async function runShot(browser, shot, outDir, format, jpegQuality, allowEval, as
       await page.waitForTimeout(shot.afterLoadMs);
     }
     const ext = format === "jpeg" ? "jpg" : "png";
-    const path23 = join13(outDir, `${shot.name}.${ext}`);
+    const path24 = join13(outDir, `${shot.name}.${ext}`);
     await page.screenshot({
-      path: path23,
+      path: path24,
       type: format,
       ...format === "jpeg" ? { quality: jpegQuality } : {},
       fullPage: false
     });
-    return { name: shot.name, path: path23, urlRedacted: redactUrl(shot.url), viewport };
+    return { name: shot.name, path: path24, urlRedacted: redactUrl(shot.url), viewport };
   } finally {
     await context.close();
   }
@@ -27930,12 +27930,12 @@ function openUrl(url) {
 var HOST_CP_URL = "http://127.0.0.1:19000";
 async function readHostCpToken2() {
   try {
-    const { default: fs19 } = await import("node:fs");
-    const { default: os12 } = await import("node:os");
-    const { default: path23 } = await import("node:path");
-    const tp = path23.join(os12.homedir(), ".olam", "host-cp.token");
-    if (!fs19.existsSync(tp)) return { token: null };
-    return { token: fs19.readFileSync(tp, "utf-8").trim() };
+    const { default: fs20 } = await import("node:fs");
+    const { default: os13 } = await import("node:os");
+    const { default: path24 } = await import("node:path");
+    const tp = path24.join(os13.homedir(), ".olam", "host-cp.token");
+    if (!fs20.existsSync(tp)) return { token: null };
+    return { token: fs20.readFileSync(tp, "utf-8").trim() };
   } catch {
     return { token: null };
   }
@@ -28382,9 +28382,9 @@ function register22(server, _ctx, _initError) {
       description: external_exports.string().optional().describe("Optional human-readable description."),
       defaultBranch: external_exports.string().optional().describe("Default branch name (e.g. main).")
     },
-    async ({ name, path: path23, description, defaultBranch }) => {
+    async ({ name, path: path24, description, defaultBranch }) => {
       try {
-        const entry = addRepo({ name, path: path23, description, defaultBranch });
+        const entry = addRepo({ name, path: path24, description, defaultBranch });
         return {
           content: [{
             type: "text",
@@ -28425,9 +28425,9 @@ function register22(server, _ctx, _initError) {
       description: external_exports.string().optional().describe("New description."),
       defaultBranch: external_exports.string().optional().describe("New default branch.")
     },
-    async ({ name, path: path23, description, defaultBranch }) => {
+    async ({ name, path: path24, description, defaultBranch }) => {
       try {
-        const entry = updateRepo(name, { path: path23, description, defaultBranch });
+        const entry = updateRepo(name, { path: path24, description, defaultBranch });
         return {
           content: [{
             type: "text",
@@ -28441,6 +28441,142 @@ function register22(server, _ctx, _initError) {
   );
 }
 
+// ../mcp-server/src/tools/process-port.ts
+var process_port_exports = {};
+__export(process_port_exports, {
+  register: () => register23,
+  resolveHostCpToken: () => resolveHostCpToken
+});
+import fs10 from "node:fs";
+import os9 from "node:os";
+import path14 from "node:path";
+var HOST_CP_BASE = "http://127.0.0.1:19000";
+function resolveHostCpToken() {
+  const envToken = process.env["OLAM_HOST_CP_TOKEN"];
+  if (envToken) return envToken;
+  const tokenPath = path14.join(os9.homedir(), ".olam", "host-cp.token");
+  if (fs10.existsSync(tokenPath)) return fs10.readFileSync(tokenPath, "utf-8").trim();
+  return null;
+}
+function tokenMissingError() {
+  return {
+    content: [{
+      type: "text",
+      text: "host-cp token not found. Set OLAM_HOST_CP_TOKEN or write ~/.olam/host-cp.token."
+    }],
+    isError: true
+  };
+}
+function asMessage5(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function register23(server, _ctx, _initError) {
+  server.tool(
+    "olam_process_list",
+    "List running processes inside a world container. Returns a process table snapshot via host-cp. Fields per process: pid, user, cpu, mem, started, state, command.",
+    {
+      world_id: external_exports.string().describe("World ID.")
+    },
+    async ({ world_id }) => {
+      const token = resolveHostCpToken();
+      if (!token) return tokenMissingError();
+      try {
+        const res = await fetch(`${HOST_CP_BASE}/api/worlds/${world_id}/processes`, {
+          headers: { Authorization: `Bearer ${token}` },
+          signal: AbortSignal.timeout(1e4)
+        });
+        const body = await res.text();
+        if (!res.ok) {
+          return {
+            content: [{ type: "text", text: `host-cp ${res.status}: ${body}` }],
+            isError: true
+          };
+        }
+        const data = JSON.parse(body);
+        return {
+          content: [{ type: "text", text: JSON.stringify({ processes: data.processes }, null, 2) }]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: asMessage5(err) }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "olam_port_expose",
+    "Expose a port inside a world container to the host by creating a socat bridge. Returns the host-side URL and bridge metadata. The bridge persists until removed with olam_port_unexpose.",
+    {
+      world_id: external_exports.string().describe("World ID."),
+      port: external_exports.number().int().min(1).max(65535).describe("Container port to expose on the host.")
+    },
+    async ({ world_id, port }) => {
+      const token = resolveHostCpToken();
+      if (!token) return tokenMissingError();
+      try {
+        const res = await fetch(`${HOST_CP_BASE}/api/worlds/${world_id}/server-bridges`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`
+          },
+          body: JSON.stringify({ port }),
+          signal: AbortSignal.timeout(3e4)
+        });
+        const body = await res.text();
+        if (!res.ok) {
+          return {
+            content: [{ type: "text", text: `host-cp ${res.status}: ${body}` }],
+            isError: true
+          };
+        }
+        const data = JSON.parse(body);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              url: `http://localhost:${data.hostPort}`,
+              host_port: data.hostPort,
+              sidecar_container_id: data.containerId,
+              container_port: data.containerPort,
+              container_name: data.containerName
+            }, null, 2)
+          }]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: asMessage5(err) }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "olam_port_unexpose",
+    "Tear down a port bridge for a world container. Removes the socat sidecar and frees the host port.",
+    {
+      world_id: external_exports.string().describe("World ID."),
+      port: external_exports.number().int().min(1).max(65535).describe("Container port whose bridge should be removed.")
+    },
+    async ({ world_id, port }) => {
+      const token = resolveHostCpToken();
+      if (!token) return tokenMissingError();
+      try {
+        const res = await fetch(`${HOST_CP_BASE}/api/worlds/${world_id}/server-bridges/${port}`, {
+          method: "DELETE",
+          headers: { Authorization: `Bearer ${token}` },
+          signal: AbortSignal.timeout(1e4)
+        });
+        if (!res.ok) {
+          const body = await res.text();
+          return {
+            content: [{ type: "text", text: `host-cp ${res.status}: ${body}` }],
+            isError: true
+          };
+        }
+        return { content: [{ type: "text", text: JSON.stringify({ ok: true }) }] };
+      } catch (err) {
+        return { content: [{ type: "text", text: asMessage5(err) }], isError: true };
+      }
+    }
+  );
+}
+
 // ../mcp-server/src/tools/index.ts
 var toolModules = [
   init_exports,
@@ -28464,7 +28600,8 @@ var toolModules = [
   lane_merge_exports,
   capture_view_exports,
   create_from_prompt_exports,
-  repo_exports
+  repo_exports,
+  process_port_exports
 ];
 function registerAllTools(server, ctx, initError) {
   for (const mod of toolModules) {
@@ -28496,8 +28633,8 @@ function createServer3(ctx, initError) {
 }
 
 // ../core/dist/config/loader.js
-import * as fs11 from "node:fs";
-import * as path14 from "node:path";
+import * as fs12 from "node:fs";
+import * as path15 from "node:path";
 import { parse as parseYaml2 } from "yaml";
 
 // ../core/dist/config/schema.js
@@ -28877,11 +29014,11 @@ function substituteEnvVars(obj) {
 }
 
 // ../core/dist/config/dotenv.js
-import * as fs10 from "node:fs";
+import * as fs11 from "node:fs";
 function loadDotEnv(envPath) {
-  if (!fs10.existsSync(envPath))
+  if (!fs11.existsSync(envPath))
     return;
-  const content = fs10.readFileSync(envPath, "utf-8");
+  const content = fs11.readFileSync(envPath, "utf-8");
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#"))
@@ -28900,18 +29037,18 @@ function loadDotEnv(envPath) {
 // ../core/dist/config/loader.js
 function findConfigFile(startDir) {
   const searched = [];
-  let current = path14.resolve(startDir);
+  let current = path15.resolve(startDir);
   while (true) {
-    const newLayout = path14.join(current, CONFIG_DIR_NAME, CONFIG_FILENAME);
-    const legacyLayout = path14.join(current, LEGACY_CONFIG_FILENAME);
+    const newLayout = path15.join(current, CONFIG_DIR_NAME, CONFIG_FILENAME);
+    const legacyLayout = path15.join(current, LEGACY_CONFIG_FILENAME);
     searched.push(newLayout, legacyLayout);
-    if (fs11.existsSync(newLayout)) {
+    if (fs12.existsSync(newLayout)) {
       return { path: newLayout, isLegacy: false };
     }
-    if (fs11.existsSync(legacyLayout)) {
+    if (fs12.existsSync(legacyLayout)) {
       return { path: legacyLayout, isLegacy: true };
     }
-    const parent = path14.dirname(current);
+    const parent = path15.dirname(current);
     if (parent === current)
       break;
     current = parent;
@@ -28926,12 +29063,12 @@ function loadConfig(startDir) {
        Run /olam:init to migrate to .olam/config.yaml
 `);
   } else {
-    const envPath = path14.join(path14.dirname(found.path), ".env");
+    const envPath = path15.join(path15.dirname(found.path), ".env");
     loadDotEnv(envPath);
   }
   let rawContent;
   try {
-    rawContent = fs11.readFileSync(found.path, "utf-8");
+    rawContent = fs12.readFileSync(found.path, "utf-8");
   } catch (err) {
     throw new Error(`Failed to read ${found.path}: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -28963,9 +29100,9 @@ function loadConfig(startDir) {
 // ../core/dist/world/manager.js
 import * as crypto4 from "node:crypto";
 import { execSync as execSync4 } from "node:child_process";
-import * as fs16 from "node:fs";
-import * as os10 from "node:os";
-import * as path20 from "node:path";
+import * as fs17 from "node:fs";
+import * as os11 from "node:os";
+import * as path21 from "node:path";
 
 // ../core/dist/world/state.js
 var VALID_TRANSITIONS = {
@@ -29047,8 +29184,8 @@ function resolveDevboxImage(config2, tag) {
 
 // ../core/dist/world/worktree.js
 import { execFileSync as execFileSync2 } from "node:child_process";
-import * as fs12 from "node:fs";
-import * as path15 from "node:path";
+import * as fs13 from "node:fs";
+import * as path16 from "node:path";
 function resolveGitDir(repo) {
   if (repo.path) {
     return repo.path;
@@ -29058,11 +29195,11 @@ function resolveGitDir(repo) {
 async function createWorktrees(repos, worldId, workspacePath, branch) {
   const created = [];
   for (const repo of repos) {
-    const worktreePath = path15.join(workspacePath, repo.name);
+    const worktreePath = path16.join(workspacePath, repo.name);
     const gitDir = resolveGitDir(repo);
     const branchName = branch || `olam/${worldId}`;
     try {
-      fs12.mkdirSync(path15.dirname(worktreePath), { recursive: true });
+      fs13.mkdirSync(path16.dirname(worktreePath), { recursive: true });
       execFileSync2("git", ["worktree", "add", worktreePath, "-b", branchName], {
         cwd: gitDir,
         stdio: "pipe"
@@ -29095,7 +29232,7 @@ async function createWorktrees(repos, worldId, workspacePath, branch) {
 }
 async function removeWorktrees(repos, workspacePath) {
   for (const repo of repos) {
-    const worktreePath = path15.join(workspacePath, repo.name);
+    const worktreePath = path16.join(workspacePath, repo.name);
     let gitDir;
     try {
       gitDir = resolveGitDir(repo);
@@ -29170,9 +29307,9 @@ function removeBranch(repo, branch) {
 
 // ../core/dist/world/baseline-diff.js
 import { execFileSync as execFileSync3 } from "node:child_process";
-import * as fs13 from "node:fs";
-import * as os9 from "node:os";
-import * as path16 from "node:path";
+import * as fs14 from "node:fs";
+import * as os10 from "node:os";
+import * as path17 from "node:path";
 var DEFAULT_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
 function expandHome(p, homedir13) {
   return p.replace(/^~(?=$|\/|\\)/, homedir13());
@@ -29198,10 +29335,10 @@ ${stderr}`;
 }
 function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
   const exec = deps.exec ?? ((cmd, args, opts) => execFileSync3(cmd, args, opts));
-  const homedir13 = deps.homedir ?? (() => os9.homedir());
-  const baselineDir = path16.join(workspacePath, ".olam", "baseline");
+  const homedir13 = deps.homedir ?? (() => os10.homedir());
+  const baselineDir = path17.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`);
@@ -29213,9 +29350,9 @@ function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
     if (!repo.path)
       continue;
     const filename = `${sanitizeRepoFilename(repo.name)}.diff`;
-    const outPath = path16.join(baselineDir, filename);
+    const outPath = path17.join(baselineDir, filename);
     const repoPath = expandHome(repo.path, homedir13);
-    if (!fs13.existsSync(repoPath)) {
+    if (!fs14.existsSync(repoPath)) {
       writeBaselineFile(outPath, `# repo: ${repo.name}
 # (skipped: path ${repoPath} does not exist)
 `);
@@ -29282,7 +29419,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}`);
@@ -29290,8 +29427,8 @@ function writeBaselineFile(outPath, content) {
 }
 function stripWorktreeEdits(repos, workspacePath) {
   for (const repo of repos) {
-    const worktreePath = path16.join(workspacePath, repo.name);
-    if (!fs13.existsSync(worktreePath))
+    const worktreePath = path17.join(workspacePath, repo.name);
+    if (!fs14.existsSync(worktreePath))
       continue;
     try {
       execFileSync3("git", ["checkout", "--", "."], {
@@ -29321,12 +29458,12 @@ function formatBaselineSummary(result) {
 }
 
 // ../core/dist/world/context-injection.js
-import * as fs14 from "node:fs";
-import * as path17 from "node:path";
+import * as fs15 from "node:fs";
+import * as path18 from "node:path";
 function injectWorldContext(opts) {
   const { world, task, linearTicketId, claudeMdExtra, taskContext, services, pleriPlaneUrl } = opts;
-  const claudeDir = path17.join(world.workspacePath, ".claude");
-  fs14.mkdirSync(claudeDir, { recursive: true });
+  const claudeDir = path18.join(world.workspacePath, ".claude");
+  fs15.mkdirSync(claudeDir, { recursive: true });
   const sections = [];
   sections.push(`# Olam World: ${world.name}`);
   sections.push("");
@@ -29487,7 +29624,7 @@ function injectWorldContext(opts) {
     sections.push("");
   }
   const content = sections.join("\n");
-  fs14.writeFileSync(path17.join(claudeDir, "CLAUDE.md"), content);
+  fs15.writeFileSync(path18.join(claudeDir, "CLAUDE.md"), content);
 }
 function formatTaskSource(ctx) {
   if (ctx.source === "linear" && ctx.ticketId) {
@@ -29501,9 +29638,9 @@ function formatTaskSource(ctx) {
 function hasPlanFile(world) {
   if (world.repos.length === 0)
     return false;
-  const plansDir = path17.join(world.workspacePath, world.repos[0], "docs", "plans");
+  const plansDir = path18.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;
   }
@@ -30169,14 +30306,14 @@ function gcloudAvailable(execFn = defaultExecFn) {
 }
 
 // ../core/dist/world/olam-yaml.js
-import * as path18 from "node:path";
+import * as path19 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 = path18.join(workspacePath, repo.name);
+    const repoDir = path19.join(workspacePath, repo.name);
     let manifest = null;
     try {
       manifest = loadRepoManifest(repoDir);
@@ -30191,8 +30328,8 @@ function enrichReposWithManifests(repos, workspacePath) {
 }
 
 // ../core/dist/policies/loader.js
-import * as fs15 from "node:fs";
-import * as path19 from "node:path";
+import * as fs16 from "node:fs";
+import * as path20 from "node:path";
 import { parse as parseYaml3 } from "yaml";
 function parseFrontmatter(content) {
   const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/m.exec(content);
@@ -30212,20 +30349,20 @@ function toStringArray(v) {
   return v.filter((x) => typeof x === "string");
 }
 function loadPolicies(workspaceRoot) {
-  const policiesDir = path19.join(workspaceRoot, ".olam", "policies");
-  if (!fs15.existsSync(policiesDir))
+  const policiesDir = path20.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 = path19.join(policiesDir, file);
+    const filePath = path20.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`);
@@ -30764,7 +30901,7 @@ var WorldManager = class {
       }
     }
     const worldId = generateWorldId();
-    const workspacePath = path20.join(os10.homedir(), ".olam", "worlds", worldId);
+    const workspacePath = path21.join(os11.homedir(), ".olam", "worlds", worldId);
     const portOffset = this.registry.getNextPortOffset();
     const branch = opts.branchName ?? `olam/${worldId}`;
     const repos = this.resolveReposWithWorkspace(opts);
@@ -30820,38 +30957,38 @@ var WorldManager = class {
     for (const repo of repos) {
       if (!repo.path)
         continue;
-      const sourceRoot = repo.path.replace(/^~/, os10.homedir());
-      const worktreeRoot = path20.join(workspacePath, repo.name);
-      if (!fs16.existsSync(sourceRoot) || !fs16.existsSync(worktreeRoot))
+      const sourceRoot = repo.path.replace(/^~/, os11.homedir());
+      const worktreeRoot = path21.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] = [path20.dirname(pattern), path20.basename(pattern)];
-          const sourceDir = path20.join(sourceRoot, dir);
-          if (fs16.existsSync(sourceDir)) {
+          const [dir, glob] = [path21.dirname(pattern), path21.basename(pattern)];
+          const sourceDir = path21.join(sourceRoot, dir);
+          if (fs17.existsSync(sourceDir)) {
             const ext = glob.replace(/^\*+/, "");
             try {
-              for (const entry of fs16.readdirSync(sourceDir)) {
+              for (const entry of fs17.readdirSync(sourceDir)) {
                 if (ext === "" || entry.endsWith(ext))
-                  matches2.push(path20.join(dir, entry));
+                  matches2.push(path21.join(dir, entry));
               }
             } catch {
             }
           }
-        } else if (fs16.existsSync(path20.join(sourceRoot, pattern))) {
+        } else if (fs17.existsSync(path21.join(sourceRoot, pattern))) {
           matches2.push(pattern);
         }
         for (const rel of matches2) {
-          const src = path20.join(sourceRoot, rel);
-          const dst = path20.join(worktreeRoot, rel);
+          const src = path21.join(sourceRoot, rel);
+          const dst = path21.join(worktreeRoot, rel);
           try {
-            const st = fs16.statSync(src);
+            const st = fs17.statSync(src);
             if (!st.isFile())
               continue;
-            fs16.mkdirSync(path20.dirname(dst), { recursive: true });
-            fs16.copyFileSync(src, dst);
+            fs17.mkdirSync(path21.dirname(dst), { recursive: true });
+            fs17.copyFileSync(src, dst);
             copied++;
           } catch {
           }
@@ -30951,7 +31088,7 @@ var WorldManager = class {
       try {
         const hostExec = makeHostExecFn();
         for (const repo of repos) {
-          const repoDir = path20.join(workspacePath, repo.name);
+          const repoDir = path21.join(workspacePath, repo.name);
           if (repo.stack && Object.keys(repo.stack).length > 0) {
             preDetectedStacks.set(repo.name, { repoName: repo.name, versions: repo.stack });
           } else {
@@ -31008,10 +31145,10 @@ var WorldManager = class {
       const worldEnv = {};
       if (opts.task)
         worldEnv.OLAM_TASK = opts.task;
-      const r2CredsPath = path20.join(os10.homedir(), ".olam", "r2-credentials.json");
-      if (fs16.existsSync(r2CredsPath)) {
+      const r2CredsPath = path21.join(os11.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")
@@ -31028,10 +31165,10 @@ var WorldManager = class {
         } catch {
         }
       }
-      const keysYamlPath = path20.join(os10.homedir(), ".olam", "keys.yaml");
-      if (fs16.existsSync(keysYamlPath)) {
+      const keysYamlPath = path21.join(os11.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)) {
@@ -31078,10 +31215,10 @@ var WorldManager = class {
             worldEnv[k] = v;
         }
         for (const { repoName, relativePath, content } of fileWrites) {
-          const absPath = path20.join(workspacePath, repoName, relativePath);
+          const absPath = path21.join(workspacePath, repoName, relativePath);
           try {
-            fs16.mkdirSync(path20.dirname(absPath), { recursive: true });
-            fs16.writeFileSync(absPath, content.endsWith("\n") ? content : content + "\n", {
+            fs17.mkdirSync(path21.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)`);
@@ -31233,7 +31370,7 @@ var WorldManager = class {
         let taskWithPolicies = opts.task;
         try {
           const allPolicies = repos.flatMap((repo) => {
-            const repoWorktree = path20.join(workspacePath, repo.name);
+            const repoWorktree = path21.join(workspacePath, repo.name);
             return loadPolicies(repoWorktree);
           });
           const seen = /* @__PURE__ */ new Set();
@@ -31249,8 +31386,8 @@ var WorldManager = class {
 ${opts.task}`;
             execSync4(`docker exec ${containerName} mkdir -p /home/olam/.olam/policies`, { stdio: "pipe", timeout: 1e4 });
             for (const repo of repos) {
-              const policiesDir = path20.join(workspacePath, repo.name, ".olam", "policies");
-              if (fs16.existsSync(policiesDir)) {
+              const policiesDir = path21.join(workspacePath, repo.name, ".olam", "policies");
+              if (fs17.existsSync(policiesDir)) {
                 execSync4(`docker cp "${policiesDir}/." "${containerName}:/home/olam/.olam/policies/"`, { stdio: "pipe", timeout: 15e3 });
               }
             }
@@ -31329,8 +31466,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) {
@@ -31415,14 +31552,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 = path20.basename(planFilePath);
+    const planContent = fs17.readFileSync(planFilePath, "utf-8");
+    const planFileName = path21.basename(planFilePath);
     const targetRepo = repoNames[0];
     if (!targetRepo)
       return;
-    const plansDir = path20.join(workspacePath, targetRepo, "docs", "plans");
-    fs16.mkdirSync(plansDir, { recursive: true });
-    fs16.writeFileSync(path20.join(plansDir, planFileName), planContent);
+    const plansDir = path21.join(workspacePath, targetRepo, "docs", "plans");
+    fs17.mkdirSync(plansDir, { recursive: true });
+    fs17.writeFileSync(path21.join(plansDir, planFileName), planContent);
   }
   resolveServices(repos) {
     const services = [];
@@ -31507,8 +31644,8 @@ import * as http2 from "node:http";
 
 // ../core/dist/dashboard/server.js
 import * as http from "node:http";
-import * as fs17 from "node:fs";
-import * as path21 from "node:path";
+import * as fs18 from "node:fs";
+import * as path22 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../core/dist/dashboard/serialize.js
@@ -31843,7 +31980,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);
 }
@@ -32014,13 +32151,13 @@ function findSessionInWorld(registry2, sessionId) {
 }
 function createDashboardServer(opts) {
   const { port, registry: registry2 } = opts;
-  const thisDir = path21.dirname(fileURLToPath2(import.meta.url));
-  const defaultPublicDir = path21.resolve(thisDir, "../../../control-plane/public");
+  const thisDir = path22.dirname(fileURLToPath2(import.meta.url));
+  const defaultPublicDir = path22.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}`);
@@ -32294,22 +32431,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 = path21.join(publicDir, pathname === "/" ? "index.html" : pathname);
+    let filePath = path22.join(publicDir, pathname === "/" ? "index.html" : pathname);
     if (!filePath.startsWith(publicDir)) {
       notFound(res);
       return;
     }
-    if (fs17.existsSync(filePath) && fs17.statSync(filePath).isFile()) {
-      const ext = path21.extname(filePath);
+    if (fs18.existsSync(filePath) && fs18.statSync(filePath).isFile()) {
+      const ext = path22.extname(filePath);
       const contentType = MIME[ext] ?? "application/octet-stream";
       res.writeHead(200, { "Content-Type": contentType });
-      fs17.createReadStream(filePath).pipe(res);
+      fs18.createReadStream(filePath).pipe(res);
       return;
     }
-    filePath = path21.join(publicDir, "index.html");
-    if (fs17.existsSync(filePath)) {
+    filePath = path22.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);
@@ -32319,17 +32456,17 @@ function createDashboardServer(opts) {
 }
 
 // ../core/dist/dashboard/state.js
-import * as fs18 from "node:fs";
-import * as os11 from "node:os";
-import * as path22 from "node:path";
-var STATE_PATH = path22.join(os11.homedir(), ".olam", "dashboard.json");
+import * as fs19 from "node:fs";
+import * as os12 from "node:os";
+import * as path23 from "node:path";
+var STATE_PATH = path23.join(os12.homedir(), ".olam", "dashboard.json");
 function saveDashboardState(state) {
-  fs18.mkdirSync(path22.dirname(STATE_PATH), { recursive: true });
-  fs18.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2));
+  fs19.mkdirSync(path23.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;
@@ -32337,7 +32474,7 @@ function loadDashboardState() {
 }
 function clearDashboardState() {
   try {
-    fs18.unlinkSync(STATE_PATH);
+    fs19.unlinkSync(STATE_PATH);
   } catch {
   }
 }
@@ -32647,9 +32784,9 @@ function findProjectRoot2(startDir) {
     dir = parent;
   }
 }
-function parseEnvFile(path23) {
+function parseEnvFile(path24) {
   const out = {};
-  const raw = readFileSync15(path23, "utf8");
+  const raw = readFileSync15(path24, "utf8");
   for (const line of raw.split(/\r?\n/)) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#")) continue;