@pleri/olam-cli 0.1.65 → 0.1.68

package/dist/mcp-server.js

@@ -3228,8 +3228,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path21) {
-      let input = path21;
+    function removeDotSegments(path23) {
+      let input = path23;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3428,8 +3428,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path21, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path21 && path21 !== "/" ? path21 : void 0;
+        const [path23, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path23 && path23 !== "/" ? path23 : 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, fs17, exportName) {
+    function addFormats(ajv, list, fs19, 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, fs17[f]);
+        ajv.addFormat(f, fs19[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, path21) {
-  if (!path21)
+function getElementAtPath(obj, path23) {
+  if (!path23)
     return obj;
-  return path21.reduce((acc, key) => acc?.[key], obj);
+  return path23.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(path21, issues) {
+function prefixIssues(path23, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path21);
+    iss.path.unshift(path23);
     return iss;
   });
 }
@@ -13403,8 +13403,8 @@ function getErrorMap() {
 
 // ../../node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path21, errorMaps, issueData } = params;
-  const fullPath = [...path21, ...issueData.path || []];
+  const { data, path: path23, errorMaps, issueData } = params;
+  const fullPath = [...path23, ...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, path21, key) {
+  constructor(parent, value, path23, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path21;
+    this._path = path23;
     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, path21, body, attempt = 0) {
-    const url = `${this.baseUrl}${path21}`;
+  async request(method, path23, body, attempt = 0) {
+    const url = `${this.baseUrl}${path23}`;
     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, path21, body, attempt + 1);
+        return this.request(method, path23, body, attempt + 1);
       }
       throw err;
     } finally {
@@ -22191,12 +22191,12 @@ function register3(server, _ctx, _initError) {
         registry2.close();
       }
       try {
-        const { default: fs17 } = await import("node:fs");
-        const { default: os10 } = await import("node:os");
-        const { default: path21 } = await import("node:path");
-        const tokenPath = path21.join(os10.homedir(), ".olam", "host-cp.token");
-        if (fs17.existsSync(tokenPath)) {
-          const token = fs17.readFileSync(tokenPath, "utf-8").trim();
+        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();
           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, path21, ctx, rejectSource) {
+function refineForbiddenKeys(value, path23, ctx, rejectSource) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     return;
   }
@@ -22397,12 +22397,12 @@ function refineForbiddenKeys(value, path21, ctx, rejectSource) {
     if (FORBIDDEN_KEYS.has(key)) {
       ctx.addIssue({
         code: external_exports.ZodIssueCode.custom,
-        path: [...path21, key],
+        path: [...path23, key],
         message: `forbidden key "${key}" (prototype-pollution surface)`
       });
       continue;
     }
-    if (rejectSource && path21.length === 0 && key === "source") {
+    if (rejectSource && path23.length === 0 && key === "source") {
       ctx.addIssue({
         code: external_exports.ZodIssueCode.custom,
         path: ["source"],
@@ -22410,21 +22410,21 @@ function refineForbiddenKeys(value, path21, ctx, rejectSource) {
       });
       continue;
     }
-    refineForbiddenKeys(value[key], [...path21, key], ctx, false);
+    refineForbiddenKeys(value[key], [...path23, key], ctx, false);
   }
 }
-function rejectForbiddenKeys(value, path21, rejectSource) {
+function rejectForbiddenKeys(value, path23, 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] ${path21}: forbidden key "${key}" (prototype-pollution surface)`);
+      throw new Error(`[manifest] ${path23}: forbidden key "${key}" (prototype-pollution surface)`);
     }
     if (rejectSource && key === "source") {
-      throw new Error(`[manifest] ${path21}: top-level "source" is loader-stamped \u2014 manifests must not author it`);
+      throw new Error(`[manifest] ${path23}: top-level "source" is loader-stamped \u2014 manifests must not author it`);
     }
-    rejectForbiddenKeys(value[key], `${path21}.${key}`, false);
+    rejectForbiddenKeys(value[key], `${path23}.${key}`, false);
   }
 }
 function unknownTopLevelKeys(parsed) {
@@ -22862,10 +22862,10 @@ function extractMcpConfig(claudeJsonPath) {
   }
   return { mcpServers, secrets };
 }
-function readOptional(path21) {
-  if (!existsSync6(path21)) return null;
+function readOptional(path23) {
+  if (!existsSync6(path23)) return null;
   try {
-    return readFileSync5(path21, "utf8");
+    return readFileSync5(path23, "utf8");
   } catch {
     return null;
   }
@@ -24008,8 +24008,8 @@ var CloudflareProvider = class extends ComputeProvider {
   // -----------------------------------------------------------------------
   // Internal fetch helper
   // -----------------------------------------------------------------------
-  async request(path21, method, body) {
-    const url = `${this.config.workerUrl}${path21}`;
+  async request(path23, method, body) {
+    const url = `${this.config.workerUrl}${path23}`;
     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 path21 = join12(args.outDir, "manifest.json");
-  await writeFile(path21, `${JSON.stringify(manifest, null, 2)}
+  const path23 = join12(args.outDir, "manifest.json");
+  await writeFile(path23, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
-  return { path: path21, manifest };
+  return { path: path23, 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 path21 = target.pathname;
-      if (!liveCompiled.some((re) => re.test(path21))) {
-        return httpReject(403, "outside_allow_list", { path: path21 });
+      const path23 = target.pathname;
+      if (!liveCompiled.some((re) => re.test(path23))) {
+        return httpReject(403, "outside_allow_list", { path: path23 });
       }
       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 path21 = join13(outDir, `${shot.name}.${ext}`);
+    const path23 = join13(outDir, `${shot.name}.${ext}`);
     await page.screenshot({
-      path: path21,
+      path: path23,
       type: format,
       ...format === "jpeg" ? { quality: jpegQuality } : {},
       fullPage: false
     });
-    return { name: shot.name, path: path21, urlRedacted: redactUrl(shot.url), viewport };
+    return { name: shot.name, path: path23, 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: fs17 } = await import("node:fs");
-    const { default: os10 } = await import("node:os");
-    const { default: path21 } = await import("node:path");
-    const tp = path21.join(os10.homedir(), ".olam", "host-cp.token");
-    if (!fs17.existsSync(tp)) return { token: null };
-    return { token: fs17.readFileSync(tp, "utf-8").trim() };
+    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() };
   } catch {
     return { token: null };
   }
@@ -28161,6 +28161,286 @@ function register21(server, ctx, initError) {
   );
 }
 
+// ../mcp-server/src/tools/repo.ts
+var repo_exports = {};
+__export(repo_exports, {
+  register: () => register22
+});
+
+// ../core/dist/global-config/schema.js
+function isAbsoluteOrTilde(p) {
+  return p.startsWith("/") || p === "~" || p.startsWith("~/");
+}
+function hasNoTraversalComponents(p) {
+  return !p.split("/").some((seg) => seg === "..");
+}
+var RepoEntrySchema = external_exports.object({
+  name: external_exports.string().regex(REPO_NAME_PATTERN, "repo name must be ASCII lowercase + digits + dash (1-64 chars, no leading/trailing dash)"),
+  path: external_exports.string().min(1, "path must not be empty").refine(isAbsoluteOrTilde, {
+    message: `path must be absolute (e.g. "/home/user/atlas-core") or "~/..." for the operator's home directory`
+  }).refine(hasNoTraversalComponents, { message: 'path must not contain ".." components' }),
+  description: external_exports.string().optional(),
+  defaultBranch: external_exports.string().optional(),
+  addedAt: external_exports.number().int().nonnegative(),
+  updatedAt: external_exports.number().int().nonnegative()
+});
+var PortMapSchema = external_exports.record(external_exports.string().min(1), external_exports.number().int().min(1024).max(65535));
+var SeedSqlFileSchema = external_exports.object({
+  type: external_exports.literal("sql-file"),
+  repo: external_exports.string().min(1),
+  service: external_exports.string().min(1),
+  path: external_exports.string().min(1)
+});
+var SeedCommandSchema = external_exports.object({
+  type: external_exports.literal("command"),
+  repo: external_exports.string().min(1),
+  run: external_exports.string().min(1)
+});
+var SeedFixtureCopySchema = external_exports.object({
+  type: external_exports.literal("fixture-copy"),
+  repo: external_exports.string().min(1),
+  src: external_exports.string().min(1),
+  dest: external_exports.string().min(1)
+});
+var SeedSchema = external_exports.discriminatedUnion("type", [
+  SeedSqlFileSchema,
+  SeedCommandSchema,
+  SeedFixtureCopySchema
+]);
+var RunbookSchema = external_exports.object({
+  name: external_exports.string().regex(WORKSPACE_NAME_PATTERN, "runbook name must be ASCII lowercase + digits + dash (1-64 chars, no leading/trailing dash)"),
+  description: external_exports.string().optional(),
+  repos: external_exports.array(external_exports.string().min(1)).min(1, "runbook must reference at least one repo"),
+  portMap: external_exports.record(external_exports.string().min(1), PortMapSchema).optional(),
+  seeds: external_exports.array(SeedSchema).optional(),
+  env: external_exports.record(external_exports.string().min(1), external_exports.record(external_exports.string().min(1), external_exports.string())).optional(),
+  updatedAt: external_exports.number().int().nonnegative()
+});
+var GlobalConfigSchema = external_exports.object({
+  schemaVersion: external_exports.literal(1),
+  repos: external_exports.array(RepoEntrySchema).optional().default([]),
+  runbooks: external_exports.array(RunbookSchema).optional().default([])
+}).strip().superRefine((val, ctx) => {
+  const repoNames = val.repos.map((r) => r.name);
+  const repoDupes = repoNames.filter((n, i) => repoNames.indexOf(n) !== i);
+  for (const d of repoDupes) {
+    ctx.addIssue({ code: external_exports.ZodIssueCode.custom, message: `duplicate repo name: "${d}"`, path: ["repos"] });
+  }
+  const rbNames = val.runbooks.map((r) => r.name);
+  const rbDupes = rbNames.filter((n, i) => rbNames.indexOf(n) !== i);
+  for (const d of rbDupes) {
+    ctx.addIssue({ code: external_exports.ZodIssueCode.custom, message: `duplicate runbook name: "${d}"`, path: ["runbooks"] });
+  }
+});
+var DEFAULT_GLOBAL_CONFIG = {
+  schemaVersion: 1,
+  repos: [],
+  runbooks: []
+};
+
+// ../core/dist/global-config/store.js
+import * as fs8 from "node:fs";
+import * as os7 from "node:os";
+import * as path12 from "node:path";
+var GlobalConfigReadError = class extends Error {
+  constructor(configPath, cause) {
+    const msg = cause instanceof Error ? cause.message : String(cause);
+    super(`Failed to read global config at ${configPath}: ${msg}. Run "olam config validate" to diagnose the issue.`);
+    this.name = "GlobalConfigReadError";
+    this.cause = cause;
+  }
+};
+function globalConfigPath() {
+  const override = process.env["OLAM_GLOBAL_CONFIG_PATH"];
+  if (override && override.length > 0)
+    return override;
+  return path12.join(os7.homedir(), ".olam", "config.json");
+}
+function readGlobalConfig() {
+  const configPath = globalConfigPath();
+  if (!fs8.existsSync(configPath)) {
+    return { ...DEFAULT_GLOBAL_CONFIG };
+  }
+  let raw;
+  try {
+    raw = fs8.readFileSync(configPath, "utf-8");
+  } catch (err) {
+    throw new GlobalConfigReadError(configPath, err);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new GlobalConfigReadError(configPath, err);
+  }
+  try {
+    return GlobalConfigSchema.parse(parsed);
+  } catch (err) {
+    throw new GlobalConfigReadError(configPath, err);
+  }
+}
+function writeGlobalConfig(config2) {
+  const configPath = globalConfigPath();
+  const validated = GlobalConfigSchema.parse(config2);
+  const dir = path12.dirname(configPath);
+  fs8.mkdirSync(dir, { recursive: true });
+  const tmp = `${configPath}.tmp-${process.pid}`;
+  fs8.writeFileSync(tmp, JSON.stringify(validated, null, 2) + "\n", { mode: 420 });
+  fs8.renameSync(tmp, configPath);
+}
+
+// ../core/dist/global-config/repos.js
+import * as fs9 from "node:fs";
+import * as os8 from "node:os";
+import * as path13 from "node:path";
+function expandPath(p) {
+  if (p === "~" || p.startsWith("~/")) {
+    return path13.join(os8.homedir(), p.slice(1));
+  }
+  return p;
+}
+function listRepos() {
+  return readGlobalConfig().repos;
+}
+function addRepo(entry) {
+  const config2 = readGlobalConfig();
+  if (config2.repos.some((r) => r.name === entry.name)) {
+    throw new Error(`repo "${entry.name}" already registered. Use "olam repos update" to change its path.`);
+  }
+  const resolvedPath = expandPath(entry.path);
+  if (!fs9.existsSync(resolvedPath)) {
+    throw new Error(`path "${entry.path}" does not exist. Verify the path is correct.`);
+  }
+  const now = Date.now();
+  const newEntry = {
+    name: entry.name,
+    path: resolvedPath,
+    addedAt: now,
+    updatedAt: now,
+    ...entry.description !== void 0 ? { description: entry.description } : {},
+    ...entry.defaultBranch !== void 0 ? { defaultBranch: entry.defaultBranch } : {}
+  };
+  writeGlobalConfig({ ...config2, repos: [...config2.repos, newEntry] });
+  return newEntry;
+}
+function removeRepo(name) {
+  const config2 = readGlobalConfig();
+  if (!config2.repos.some((r) => r.name === name)) {
+    throw new Error(`repo "${name}" is not registered. Run "olam repos list" to see registered repos.`);
+  }
+  writeGlobalConfig({ ...config2, repos: config2.repos.filter((r) => r.name !== name) });
+}
+function updateRepo(name, updates) {
+  const config2 = readGlobalConfig();
+  const idx = config2.repos.findIndex((r) => r.name === name);
+  if (idx === -1) {
+    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 && !fs9.existsSync(resolvedUpdatePath)) {
+    throw new Error(`path "${updates.path}" does not exist. Verify the path is correct.`);
+  }
+  const existing = config2.repos[idx];
+  const updated = {
+    ...existing,
+    ...resolvedUpdatePath !== void 0 ? { path: resolvedUpdatePath } : {},
+    ...updates.description !== void 0 ? { description: updates.description } : {},
+    ...updates.defaultBranch !== void 0 ? { defaultBranch: updates.defaultBranch } : {},
+    updatedAt: Date.now()
+  };
+  const newRepos = [...config2.repos];
+  newRepos[idx] = updated;
+  writeGlobalConfig({ ...config2, repos: newRepos });
+  return updated;
+}
+
+// ../mcp-server/src/tools/repo.ts
+function asMessage4(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function register22(server, _ctx, _initError) {
+  server.tool(
+    "olam_repo_list",
+    "List every repo registered in ~/.olam/config.json. Returns { repos: RepoEntry[] }.",
+    {},
+    async () => {
+      const repos = listRepos();
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ repos }, null, 2)
+        }]
+      };
+    }
+  );
+  server.tool(
+    "olam_repo_add",
+    "Register a local repo path in the global registry. The path must exist on disk. Rejects duplicate names.",
+    {
+      name: external_exports.string().min(1).describe("Repo name (lowercase, digits, dash; 1\u201364 chars)."),
+      path: external_exports.string().min(1).describe("Absolute or ~/... path to the local repo directory."),
+      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 }) => {
+      try {
+        const entry = addRepo({ name, path: path23, description, defaultBranch });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ name: entry.name, path: entry.path, message: `Registered repo "${entry.name}".` })
+          }]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: asMessage4(err) }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "olam_repo_remove",
+    "Remove a repo from the global registry. Does not delete any files on disk.",
+    {
+      name: external_exports.string().min(1).describe("Repo name to remove.")
+    },
+    async ({ name }) => {
+      try {
+        removeRepo(name);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ name, message: `Removed repo "${name}".` })
+          }]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: asMessage4(err) }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "olam_repo_update",
+    "Update a registered repo's path, description, or default branch.",
+    {
+      name: external_exports.string().min(1).describe("Repo name to update."),
+      path: external_exports.string().optional().describe("New local path."),
+      description: external_exports.string().optional().describe("New description."),
+      defaultBranch: external_exports.string().optional().describe("New default branch.")
+    },
+    async ({ name, path: path23, description, defaultBranch }) => {
+      try {
+        const entry = updateRepo(name, { path: path23, description, defaultBranch });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ name: entry.name, path: entry.path, message: `Updated repo "${entry.name}".` })
+          }]
+        };
+      } catch (err) {
+        return { content: [{ type: "text", text: asMessage4(err) }], isError: true };
+      }
+    }
+  );
+}
+
 // ../mcp-server/src/tools/index.ts
 var toolModules = [
   init_exports,
@@ -28183,7 +28463,8 @@ var toolModules = [
   lane_destroy_exports,
   lane_merge_exports,
   capture_view_exports,
-  create_from_prompt_exports
+  create_from_prompt_exports,
+  repo_exports
 ];
 function registerAllTools(server, ctx, initError) {
   for (const mod of toolModules) {
@@ -28215,8 +28496,8 @@ function createServer3(ctx, initError) {
 }
 
 // ../core/dist/config/loader.js
-import * as fs9 from "node:fs";
-import * as path12 from "node:path";
+import * as fs11 from "node:fs";
+import * as path14 from "node:path";
 import { parse as parseYaml2 } from "yaml";
 
 // ../core/dist/config/schema.js
@@ -28596,11 +28877,11 @@ function substituteEnvVars(obj) {
 }
 
 // ../core/dist/config/dotenv.js
-import * as fs8 from "node:fs";
+import * as fs10 from "node:fs";
 function loadDotEnv(envPath) {
-  if (!fs8.existsSync(envPath))
+  if (!fs10.existsSync(envPath))
     return;
-  const content = fs8.readFileSync(envPath, "utf-8");
+  const content = fs10.readFileSync(envPath, "utf-8");
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#"))
@@ -28619,18 +28900,18 @@ function loadDotEnv(envPath) {
 // ../core/dist/config/loader.js
 function findConfigFile(startDir) {
   const searched = [];
-  let current = path12.resolve(startDir);
+  let current = path14.resolve(startDir);
   while (true) {
-    const newLayout = path12.join(current, CONFIG_DIR_NAME, CONFIG_FILENAME);
-    const legacyLayout = path12.join(current, LEGACY_CONFIG_FILENAME);
+    const newLayout = path14.join(current, CONFIG_DIR_NAME, CONFIG_FILENAME);
+    const legacyLayout = path14.join(current, LEGACY_CONFIG_FILENAME);
     searched.push(newLayout, legacyLayout);
-    if (fs9.existsSync(newLayout)) {
+    if (fs11.existsSync(newLayout)) {
       return { path: newLayout, isLegacy: false };
     }
-    if (fs9.existsSync(legacyLayout)) {
+    if (fs11.existsSync(legacyLayout)) {
       return { path: legacyLayout, isLegacy: true };
     }
-    const parent = path12.dirname(current);
+    const parent = path14.dirname(current);
     if (parent === current)
       break;
     current = parent;
@@ -28645,12 +28926,12 @@ function loadConfig(startDir) {
        Run /olam:init to migrate to .olam/config.yaml
 `);
   } else {
-    const envPath = path12.join(path12.dirname(found.path), ".env");
+    const envPath = path14.join(path14.dirname(found.path), ".env");
     loadDotEnv(envPath);
   }
   let rawContent;
   try {
-    rawContent = fs9.readFileSync(found.path, "utf-8");
+    rawContent = fs11.readFileSync(found.path, "utf-8");
   } catch (err) {
     throw new Error(`Failed to read ${found.path}: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -28682,9 +28963,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 fs14 from "node:fs";
-import * as os8 from "node:os";
-import * as path18 from "node:path";
+import * as fs16 from "node:fs";
+import * as os10 from "node:os";
+import * as path20 from "node:path";
 
 // ../core/dist/world/state.js
 var VALID_TRANSITIONS = {
@@ -28766,8 +29047,8 @@ function resolveDevboxImage(config2, tag) {
 
 // ../core/dist/world/worktree.js
 import { execFileSync as execFileSync2 } from "node:child_process";
-import * as fs10 from "node:fs";
-import * as path13 from "node:path";
+import * as fs12 from "node:fs";
+import * as path15 from "node:path";
 function resolveGitDir(repo) {
   if (repo.path) {
     return repo.path;
@@ -28777,11 +29058,11 @@ function resolveGitDir(repo) {
 async function createWorktrees(repos, worldId, workspacePath, branch) {
   const created = [];
   for (const repo of repos) {
-    const worktreePath = path13.join(workspacePath, repo.name);
+    const worktreePath = path15.join(workspacePath, repo.name);
     const gitDir = resolveGitDir(repo);
     const branchName = branch || `olam/${worldId}`;
     try {
-      fs10.mkdirSync(path13.dirname(worktreePath), { recursive: true });
+      fs12.mkdirSync(path15.dirname(worktreePath), { recursive: true });
       execFileSync2("git", ["worktree", "add", worktreePath, "-b", branchName], {
         cwd: gitDir,
         stdio: "pipe"
@@ -28814,7 +29095,7 @@ async function createWorktrees(repos, worldId, workspacePath, branch) {
 }
 async function removeWorktrees(repos, workspacePath) {
   for (const repo of repos) {
-    const worktreePath = path13.join(workspacePath, repo.name);
+    const worktreePath = path15.join(workspacePath, repo.name);
     let gitDir;
     try {
       gitDir = resolveGitDir(repo);
@@ -28889,12 +29170,12 @@ function removeBranch(repo, branch) {
 
 // ../core/dist/world/baseline-diff.js
 import { execFileSync as execFileSync3 } from "node:child_process";
-import * as fs11 from "node:fs";
-import * as os7 from "node:os";
-import * as path14 from "node:path";
+import * as fs13 from "node:fs";
+import * as os9 from "node:os";
+import * as path16 from "node:path";
 var DEFAULT_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
-function expandHome(p, homedir11) {
-  return p.replace(/^~(?=$|\/|\\)/, homedir11());
+function expandHome(p, homedir13) {
+  return p.replace(/^~(?=$|\/|\\)/, homedir13());
 }
 function sanitizeRepoFilename(name) {
   const sanitized = name.replace(/[^A-Za-z0-9._-]/g, "_");
@@ -28917,10 +29198,10 @@ ${stderr}`;
 }
 function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
   const exec = deps.exec ?? ((cmd, args, opts) => execFileSync3(cmd, args, opts));
-  const homedir11 = deps.homedir ?? (() => os7.homedir());
-  const baselineDir = path14.join(workspacePath, ".olam", "baseline");
+  const homedir13 = deps.homedir ?? (() => os9.homedir());
+  const baselineDir = path16.join(workspacePath, ".olam", "baseline");
   try {
-    fs11.mkdirSync(baselineDir, { recursive: true });
+    fs13.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`);
@@ -28932,9 +29213,9 @@ function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
     if (!repo.path)
       continue;
     const filename = `${sanitizeRepoFilename(repo.name)}.diff`;
-    const outPath = path14.join(baselineDir, filename);
-    const repoPath = expandHome(repo.path, homedir11);
-    if (!fs11.existsSync(repoPath)) {
+    const outPath = path16.join(baselineDir, filename);
+    const repoPath = expandHome(repo.path, homedir13);
+    if (!fs13.existsSync(repoPath)) {
       writeBaselineFile(outPath, `# repo: ${repo.name}
 # (skipped: path ${repoPath} does not exist)
 `);
@@ -29001,7 +29282,7 @@ function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
 }
 function writeBaselineFile(outPath, content) {
   try {
-    fs11.writeFileSync(outPath, content);
+    fs13.writeFileSync(outPath, content);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.warn(`[baseline-diff] write to ${outPath} failed: ${msg}`);
@@ -29009,8 +29290,8 @@ function writeBaselineFile(outPath, content) {
 }
 function stripWorktreeEdits(repos, workspacePath) {
   for (const repo of repos) {
-    const worktreePath = path14.join(workspacePath, repo.name);
-    if (!fs11.existsSync(worktreePath))
+    const worktreePath = path16.join(workspacePath, repo.name);
+    if (!fs13.existsSync(worktreePath))
       continue;
     try {
       execFileSync3("git", ["checkout", "--", "."], {
@@ -29040,12 +29321,12 @@ function formatBaselineSummary(result) {
 }
 
 // ../core/dist/world/context-injection.js
-import * as fs12 from "node:fs";
-import * as path15 from "node:path";
+import * as fs14 from "node:fs";
+import * as path17 from "node:path";
 function injectWorldContext(opts) {
   const { world, task, linearTicketId, claudeMdExtra, taskContext, services, pleriPlaneUrl } = opts;
-  const claudeDir = path15.join(world.workspacePath, ".claude");
-  fs12.mkdirSync(claudeDir, { recursive: true });
+  const claudeDir = path17.join(world.workspacePath, ".claude");
+  fs14.mkdirSync(claudeDir, { recursive: true });
   const sections = [];
   sections.push(`# Olam World: ${world.name}`);
   sections.push("");
@@ -29206,7 +29487,7 @@ function injectWorldContext(opts) {
     sections.push("");
   }
   const content = sections.join("\n");
-  fs12.writeFileSync(path15.join(claudeDir, "CLAUDE.md"), content);
+  fs14.writeFileSync(path17.join(claudeDir, "CLAUDE.md"), content);
 }
 function formatTaskSource(ctx) {
   if (ctx.source === "linear" && ctx.ticketId) {
@@ -29220,9 +29501,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 = path17.join(world.workspacePath, world.repos[0], "docs", "plans");
   try {
-    return fs12.existsSync(plansDir) && fs12.readdirSync(plansDir).length > 0;
+    return fs14.existsSync(plansDir) && fs14.readdirSync(plansDir).length > 0;
   } catch {
     return false;
   }
@@ -29888,14 +30169,14 @@ function gcloudAvailable(execFn = defaultExecFn) {
 }
 
 // ../core/dist/world/olam-yaml.js
-import * as path16 from "node:path";
+import * as path18 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 = path18.join(workspacePath, repo.name);
     let manifest = null;
     try {
       manifest = loadRepoManifest(repoDir);
@@ -29910,8 +30191,8 @@ function enrichReposWithManifests(repos, workspacePath) {
 }
 
 // ../core/dist/policies/loader.js
-import * as fs13 from "node:fs";
-import * as path17 from "node:path";
+import * as fs15 from "node:fs";
+import * as path19 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);
@@ -29931,20 +30212,20 @@ function toStringArray(v) {
   return v.filter((x) => typeof x === "string");
 }
 function loadPolicies(workspaceRoot) {
-  const policiesDir = path17.join(workspaceRoot, ".olam", "policies");
-  if (!fs13.existsSync(policiesDir))
+  const policiesDir = path19.join(workspaceRoot, ".olam", "policies");
+  if (!fs15.existsSync(policiesDir))
     return [];
   let files;
   try {
-    files = fs13.readdirSync(policiesDir).filter((f) => f.endsWith(".md")).sort();
+    files = fs15.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 = path19.join(policiesDir, file);
     try {
-      const content = fs13.readFileSync(filePath, "utf8");
+      const content = fs15.readFileSync(filePath, "utf8");
       const parsed = parseFrontmatter(content);
       if (!parsed) {
         console.warn(`[policies] skipping ${file}: no valid frontmatter block`);
@@ -30483,7 +30764,7 @@ var WorldManager = class {
       }
     }
     const worldId = generateWorldId();
-    const workspacePath = path18.join(os8.homedir(), ".olam", "worlds", worldId);
+    const workspacePath = path20.join(os10.homedir(), ".olam", "worlds", worldId);
     const portOffset = this.registry.getNextPortOffset();
     const branch = opts.branchName ?? `olam/${worldId}`;
     const repos = this.resolveReposWithWorkspace(opts);
@@ -30539,38 +30820,38 @@ var WorldManager = class {
     for (const repo of repos) {
       if (!repo.path)
         continue;
-      const sourceRoot = repo.path.replace(/^~/, os8.homedir());
-      const worktreeRoot = path18.join(workspacePath, repo.name);
-      if (!fs14.existsSync(sourceRoot) || !fs14.existsSync(worktreeRoot))
+      const sourceRoot = repo.path.replace(/^~/, os10.homedir());
+      const worktreeRoot = path20.join(workspacePath, repo.name);
+      if (!fs16.existsSync(sourceRoot) || !fs16.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 (fs14.existsSync(sourceDir)) {
+          const [dir, glob] = [path20.dirname(pattern), path20.basename(pattern)];
+          const sourceDir = path20.join(sourceRoot, dir);
+          if (fs16.existsSync(sourceDir)) {
             const ext = glob.replace(/^\*+/, "");
             try {
-              for (const entry of fs14.readdirSync(sourceDir)) {
+              for (const entry of fs16.readdirSync(sourceDir)) {
                 if (ext === "" || entry.endsWith(ext))
-                  matches2.push(path18.join(dir, entry));
+                  matches2.push(path20.join(dir, entry));
               }
             } catch {
             }
           }
-        } else if (fs14.existsSync(path18.join(sourceRoot, pattern))) {
+        } else if (fs16.existsSync(path20.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 = path20.join(sourceRoot, rel);
+          const dst = path20.join(worktreeRoot, rel);
           try {
-            const st = fs14.statSync(src);
+            const st = fs16.statSync(src);
             if (!st.isFile())
               continue;
-            fs14.mkdirSync(path18.dirname(dst), { recursive: true });
-            fs14.copyFileSync(src, dst);
+            fs16.mkdirSync(path20.dirname(dst), { recursive: true });
+            fs16.copyFileSync(src, dst);
             copied++;
           } catch {
           }
@@ -30670,7 +30951,7 @@ var WorldManager = class {
       try {
         const hostExec = makeHostExecFn();
         for (const repo of repos) {
-          const repoDir = path18.join(workspacePath, repo.name);
+          const repoDir = path20.join(workspacePath, repo.name);
           if (repo.stack && Object.keys(repo.stack).length > 0) {
             preDetectedStacks.set(repo.name, { repoName: repo.name, versions: repo.stack });
           } else {
@@ -30727,10 +31008,10 @@ var WorldManager = class {
       const worldEnv = {};
       if (opts.task)
         worldEnv.OLAM_TASK = opts.task;
-      const r2CredsPath = path18.join(os8.homedir(), ".olam", "r2-credentials.json");
-      if (fs14.existsSync(r2CredsPath)) {
+      const r2CredsPath = path20.join(os10.homedir(), ".olam", "r2-credentials.json");
+      if (fs16.existsSync(r2CredsPath)) {
         try {
-          const r2Raw = fs14.readFileSync(r2CredsPath, "utf-8").trim();
+          const r2Raw = fs16.readFileSync(r2CredsPath, "utf-8").trim();
           if (r2Raw.length > 0) {
             const r2 = JSON.parse(r2Raw);
             if (typeof r2.account_id === "string")
@@ -30747,10 +31028,10 @@ var WorldManager = class {
         } catch {
         }
       }
-      const keysYamlPath = path18.join(os8.homedir(), ".olam", "keys.yaml");
-      if (fs14.existsSync(keysYamlPath)) {
+      const keysYamlPath = path20.join(os10.homedir(), ".olam", "keys.yaml");
+      if (fs16.existsSync(keysYamlPath)) {
         try {
-          const keysRaw = fs14.readFileSync(keysYamlPath, "utf-8").trim();
+          const keysRaw = fs16.readFileSync(keysYamlPath, "utf-8").trim();
           if (keysRaw.length > 0) {
             const parsed = YAML3.parse(keysRaw);
             if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
@@ -30797,10 +31078,10 @@ var WorldManager = class {
             worldEnv[k] = v;
         }
         for (const { repoName, relativePath, content } of fileWrites) {
-          const absPath = path18.join(workspacePath, repoName, relativePath);
+          const absPath = path20.join(workspacePath, repoName, relativePath);
           try {
-            fs14.mkdirSync(path18.dirname(absPath), { recursive: true });
-            fs14.writeFileSync(absPath, content.endsWith("\n") ? content : content + "\n", {
+            fs16.mkdirSync(path20.dirname(absPath), { recursive: true });
+            fs16.writeFileSync(absPath, content.endsWith("\n") ? content : content + "\n", {
               mode: 384
             });
             console.log(`[secrets] ${repoName}: materialised ${relativePath} (${content.length} chars, mode 0600)`);
@@ -30952,7 +31233,7 @@ var WorldManager = class {
         let taskWithPolicies = opts.task;
         try {
           const allPolicies = repos.flatMap((repo) => {
-            const repoWorktree = path18.join(workspacePath, repo.name);
+            const repoWorktree = path20.join(workspacePath, repo.name);
             return loadPolicies(repoWorktree);
           });
           const seen = /* @__PURE__ */ new Set();
@@ -30968,8 +31249,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 = path18.join(workspacePath, repo.name, ".olam", "policies");
-              if (fs14.existsSync(policiesDir)) {
+              const policiesDir = path20.join(workspacePath, repo.name, ".olam", "policies");
+              if (fs16.existsSync(policiesDir)) {
                 execSync4(`docker cp "${policiesDir}/." "${containerName}:/home/olam/.olam/policies/"`, { stdio: "pipe", timeout: 15e3 });
               }
             }
@@ -31048,8 +31329,8 @@ ${opts.task}`;
     } catch {
     }
     try {
-      fs14.rmSync(world.workspacePath, { recursive: true, force: true });
-      if (fs14.existsSync(world.workspacePath)) {
+      fs16.rmSync(world.workspacePath, { recursive: true, force: true });
+      if (fs16.existsSync(world.workspacePath)) {
         console.warn(`[WorldManager] destroyWorld(${worldId}): workspace dir ${world.workspacePath} still exists after rmSync. Run \`olam clean --apply\` to reap.`);
       }
     } catch (err) {
@@ -31134,14 +31415,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 = fs14.readFileSync(planFilePath, "utf-8");
-    const planFileName = path18.basename(planFilePath);
+    const planContent = fs16.readFileSync(planFilePath, "utf-8");
+    const planFileName = path20.basename(planFilePath);
     const targetRepo = repoNames[0];
     if (!targetRepo)
       return;
-    const plansDir = path18.join(workspacePath, targetRepo, "docs", "plans");
-    fs14.mkdirSync(plansDir, { recursive: true });
-    fs14.writeFileSync(path18.join(plansDir, planFileName), planContent);
+    const plansDir = path20.join(workspacePath, targetRepo, "docs", "plans");
+    fs16.mkdirSync(plansDir, { recursive: true });
+    fs16.writeFileSync(path20.join(plansDir, planFileName), planContent);
   }
   resolveServices(repos) {
     const services = [];
@@ -31226,8 +31507,8 @@ import * as http2 from "node:http";
 
 // ../core/dist/dashboard/server.js
 import * as http from "node:http";
-import * as fs15 from "node:fs";
-import * as path19 from "node:path";
+import * as fs17 from "node:fs";
+import * as path21 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../core/dist/dashboard/serialize.js
@@ -31562,7 +31843,7 @@ function notFound(res) {
 }
 function openThoughtStore(workspacePath) {
   const dbPath = getWorldDbPath(workspacePath);
-  if (!fs15.existsSync(dbPath))
+  if (!fs17.existsSync(dbPath))
     return null;
   return new ThoughtLocalStore(dbPath);
 }
@@ -31733,13 +32014,13 @@ function findSessionInWorld(registry2, sessionId) {
 }
 function createDashboardServer(opts) {
   const { port, registry: registry2 } = opts;
-  const thisDir = path19.dirname(fileURLToPath2(import.meta.url));
-  const defaultPublicDir = path19.resolve(thisDir, "../../../control-plane/public");
+  const thisDir = path21.dirname(fileURLToPath2(import.meta.url));
+  const defaultPublicDir = path21.resolve(thisDir, "../../../control-plane/public");
   const publicDir = opts.publicDir ?? defaultPublicDir;
-  let hasPublicDir = fs15.existsSync(publicDir);
+  let hasPublicDir = fs17.existsSync(publicDir);
   const server = http.createServer((req, res) => {
     if (!hasPublicDir) {
-      hasPublicDir = fs15.existsSync(publicDir);
+      hasPublicDir = fs17.existsSync(publicDir);
     }
     const host = req.headers.host ?? `localhost:${port}`;
     const url = new URL(req.url ?? "/", `http://${host}`);
@@ -32013,22 +32294,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 = path19.join(publicDir, pathname === "/" ? "index.html" : pathname);
+    let filePath = path21.join(publicDir, pathname === "/" ? "index.html" : pathname);
     if (!filePath.startsWith(publicDir)) {
       notFound(res);
       return;
     }
-    if (fs15.existsSync(filePath) && fs15.statSync(filePath).isFile()) {
-      const ext = path19.extname(filePath);
+    if (fs17.existsSync(filePath) && fs17.statSync(filePath).isFile()) {
+      const ext = path21.extname(filePath);
       const contentType = MIME[ext] ?? "application/octet-stream";
       res.writeHead(200, { "Content-Type": contentType });
-      fs15.createReadStream(filePath).pipe(res);
+      fs17.createReadStream(filePath).pipe(res);
       return;
     }
-    filePath = path19.join(publicDir, "index.html");
-    if (fs15.existsSync(filePath)) {
+    filePath = path21.join(publicDir, "index.html");
+    if (fs17.existsSync(filePath)) {
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-      fs15.createReadStream(filePath).pipe(res);
+      fs17.createReadStream(filePath).pipe(res);
       return;
     }
     notFound(res);
@@ -32038,17 +32319,17 @@ function createDashboardServer(opts) {
 }
 
 // ../core/dist/dashboard/state.js
-import * as fs16 from "node:fs";
-import * as os9 from "node:os";
-import * as path20 from "node:path";
-var STATE_PATH = path20.join(os9.homedir(), ".olam", "dashboard.json");
+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");
 function saveDashboardState(state) {
-  fs16.mkdirSync(path20.dirname(STATE_PATH), { recursive: true });
-  fs16.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2));
+  fs18.mkdirSync(path22.dirname(STATE_PATH), { recursive: true });
+  fs18.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2));
 }
 function loadDashboardState() {
   try {
-    const raw = fs16.readFileSync(STATE_PATH, "utf-8");
+    const raw = fs18.readFileSync(STATE_PATH, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -32056,7 +32337,7 @@ function loadDashboardState() {
 }
 function clearDashboardState() {
   try {
-    fs16.unlinkSync(STATE_PATH);
+    fs18.unlinkSync(STATE_PATH);
   } catch {
   }
 }
@@ -32336,8 +32617,8 @@ var PleriClient = class {
 };
 
 // ../mcp-server/src/env-loader.ts
-import { readFileSync as readFileSync14, existsSync as existsSync17, statSync as statSync6 } from "node:fs";
-import { join as join23, dirname as dirname12, resolve as resolve5 } from "node:path";
+import { readFileSync as readFileSync15, existsSync as existsSync19, statSync as statSync6 } from "node:fs";
+import { join as join25, dirname as dirname13, resolve as resolve5 } from "node:path";
 var PROJECT_MARKERS = [
   ".olam/config.yaml",
   ".olam/config.yml",
@@ -32349,26 +32630,26 @@ function findProjectRoot2(startDir) {
   const root = resolve5("/");
   while (true) {
     for (const marker of PROJECT_MARKERS) {
-      if (existsSync17(join23(dir, marker))) return dir;
+      if (existsSync19(join25(dir, marker))) return dir;
     }
-    const pkg = join23(dir, "package.json");
-    if (existsSync17(pkg)) {
+    const pkg = join25(dir, "package.json");
+    if (existsSync19(pkg)) {
       try {
-        const json = JSON.parse(readFileSync14(pkg, "utf8"));
+        const json = JSON.parse(readFileSync15(pkg, "utf8"));
         const isOlamWorkspace = typeof json.name === "string" && json.name.startsWith("@olam/");
         const hasOlamDep = json.dependencies && Object.keys(json.dependencies).some((k) => k.startsWith("@olam/")) || json.devDependencies && Object.keys(json.devDependencies).some((k) => k.startsWith("@olam/"));
         if (isOlamWorkspace || hasOlamDep) return dir;
       } catch {
       }
     }
-    const parent = dirname12(dir);
+    const parent = dirname13(dir);
     if (parent === dir || parent === root) return null;
     dir = parent;
   }
 }
-function parseEnvFile(path21) {
+function parseEnvFile(path23) {
   const out = {};
-  const raw = readFileSync14(path21, "utf8");
+  const raw = readFileSync15(path23, "utf8");
   for (const line of raw.split(/\r?\n/)) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#")) continue;
@@ -32391,8 +32672,8 @@ function loadProjectEnv(startDir = process.cwd()) {
   const filesRead = [];
   const merged = {};
   for (const name of [".env", ".env.local"]) {
-    const p = join23(root, name);
-    if (existsSync17(p) && statSync6(p).isFile()) {
+    const p = join25(root, name);
+    if (existsSync19(p) && statSync6(p).isFile()) {
       Object.assign(merged, parseEnvFile(p));
       filesRead.push(p);
     }