@pleri/olam-cli 0.1.74 → 0.1.76

package/dist/mcp-server.js

@@ -6791,12 +6791,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs23, exportName) {
+    function addFormats(ajv, list, fs24, 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, fs23[f]);
+        ajv.addFormat(f, fs24[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -22191,12 +22191,12 @@ function register3(server, _ctx, _initError) {
         registry2.close();
       }
       try {
-        const { default: fs23 } = await import("node:fs");
+        const { default: fs24 } = await import("node:fs");
         const { default: os15 } = await import("node:os");
         const { default: path27 } = await import("node:path");
         const tokenPath = path27.join(os15.homedir(), ".olam", "host-cp.token");
-        if (fs23.existsSync(tokenPath)) {
-          const token = fs23.readFileSync(tokenPath, "utf-8").trim();
+        if (fs24.existsSync(tokenPath)) {
+          const token = fs24.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}` },
@@ -27938,12 +27938,12 @@ function openUrl(url) {
 var HOST_CP_URL = "http://127.0.0.1:19000";
 async function readHostCpToken2() {
   try {
-    const { default: fs23 } = await import("node:fs");
+    const { default: fs24 } = await import("node:fs");
     const { default: os15 } = await import("node:os");
     const { default: path27 } = await import("node:path");
     const tp = path27.join(os15.homedir(), ".olam", "host-cp.token");
-    if (!fs23.existsSync(tp)) return { token: null };
-    return { token: fs23.readFileSync(tp, "utf-8").trim() };
+    if (!fs24.existsSync(tp)) return { token: null };
+    return { token: fs24.readFileSync(tp, "utf-8").trim() };
   } catch {
     return { token: null };
   }
@@ -28187,6 +28187,7 @@ var RepoEntrySchema = external_exports.object({
   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' }),
+  url: external_exports.string().min(1, "url must not be empty").optional(),
   description: external_exports.string().optional(),
   defaultBranch: external_exports.string().optional(),
   addedAt: external_exports.number().int().nonnegative(),
@@ -28524,6 +28525,38 @@ function validateRunbookPorts(runbook, deps) {
   return { conflicts };
 }
 
+// ../core/dist/global-config/bridge.js
+import * as fs10 from "node:fs";
+function repoEntryToRepoConfig(entry) {
+  if (!entry.url) {
+    throw new Error(`Repo "${entry.name}" has no url. Re-register:
+  olam repos remove ${entry.name}
+  olam repos add ${entry.name} --path ${entry.path}`);
+  }
+  const repoPath = resolveTildePath(entry.path);
+  if (!fs10.existsSync(repoPath)) {
+    throw new Error(`Repo "${entry.name}" path "${repoPath}" no longer exists. Run: olam repos update ${entry.name} --path <new-path>`);
+  }
+  let manifest = null;
+  try {
+    manifest = loadRepoManifest(repoPath);
+  } catch {
+  }
+  const config2 = {
+    name: entry.name,
+    url: entry.url,
+    // RepoEntry has no type field; generic is the safe universal default.
+    // Operators needing non-generic type behavior should declare the repo in local config.
+    type: "generic",
+    path: repoPath,
+    submodules: false,
+    services: [],
+    setup_commands: [],
+    ...manifest !== null ? { manifest } : {}
+  };
+  return config2;
+}
+
 // ../mcp-server/src/tools/repo.ts
 function asMessage4(err) {
   return err instanceof Error ? err.message : String(err);
@@ -28617,7 +28650,7 @@ __export(process_port_exports, {
   register: () => register23,
   resolveHostCpToken: () => resolveHostCpToken
 });
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 import os9 from "node:os";
 import path14 from "node:path";
 var HOST_CP_BASE = "http://127.0.0.1:19000";
@@ -28625,7 +28658,7 @@ 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();
+  if (fs11.existsSync(tokenPath)) return fs11.readFileSync(tokenPath, "utf-8").trim();
   return null;
 }
 function tokenMissingError() {
@@ -28961,7 +28994,7 @@ function createServer4(ctx, initError) {
 }
 
 // ../core/dist/config/loader.js
-import * as fs12 from "node:fs";
+import * as fs13 from "node:fs";
 import * as path15 from "node:path";
 import { parse as parseYaml2 } from "yaml";
 
@@ -29342,11 +29375,11 @@ function substituteEnvVars(obj) {
 }
 
 // ../core/dist/config/dotenv.js
-import * as fs11 from "node:fs";
+import * as fs12 from "node:fs";
 function loadDotEnv(envPath) {
-  if (!fs11.existsSync(envPath))
+  if (!fs12.existsSync(envPath))
     return;
-  const content = fs11.readFileSync(envPath, "utf-8");
+  const content = fs12.readFileSync(envPath, "utf-8");
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
     if (!trimmed || trimmed.startsWith("#"))
@@ -29370,10 +29403,10 @@ function findConfigFile(startDir) {
     const newLayout = path15.join(current, CONFIG_DIR_NAME, CONFIG_FILENAME);
     const legacyLayout = path15.join(current, LEGACY_CONFIG_FILENAME);
     searched.push(newLayout, legacyLayout);
-    if (fs12.existsSync(newLayout)) {
+    if (fs13.existsSync(newLayout)) {
       return { path: newLayout, isLegacy: false };
     }
-    if (fs12.existsSync(legacyLayout)) {
+    if (fs13.existsSync(legacyLayout)) {
       return { path: legacyLayout, isLegacy: true };
     }
     const parent = path15.dirname(current);
@@ -29396,7 +29429,7 @@ function loadConfig(startDir) {
   }
   let rawContent;
   try {
-    rawContent = fs12.readFileSync(found.path, "utf-8");
+    rawContent = fs13.readFileSync(found.path, "utf-8");
   } catch (err) {
     throw new Error(`Failed to read ${found.path}: ${err instanceof Error ? err.message : String(err)}`);
   }
@@ -29428,7 +29461,7 @@ function loadConfig(startDir) {
 // ../core/dist/world/manager.js
 import * as crypto5 from "node:crypto";
 import { execSync as execSync5 } from "node:child_process";
-import * as fs20 from "node:fs";
+import * as fs21 from "node:fs";
 import * as os13 from "node:os";
 import * as path24 from "node:path";
 
@@ -29526,7 +29559,7 @@ function resolveDevboxImage(config2, tag) {
 
 // ../core/dist/world/worktree.js
 import { execFileSync as execFileSync2 } from "node:child_process";
-import * as fs13 from "node:fs";
+import * as fs14 from "node:fs";
 import * as path16 from "node:path";
 function resolveGitDir(repo) {
   if (repo.path) {
@@ -29541,7 +29574,7 @@ async function createWorktrees(repos, worldId, workspacePath, branch) {
     const gitDir = resolveGitDir(repo);
     const branchName = branch || `olam/${worldId}`;
     try {
-      fs13.mkdirSync(path16.dirname(worktreePath), { recursive: true });
+      fs14.mkdirSync(path16.dirname(worktreePath), { recursive: true });
       execFileSync2("git", ["worktree", "add", worktreePath, "-b", branchName], {
         cwd: gitDir,
         stdio: "pipe"
@@ -29649,7 +29682,7 @@ function removeBranch(repo, branch) {
 
 // ../core/dist/world/baseline-diff.js
 import { execFileSync as execFileSync3 } from "node:child_process";
-import * as fs14 from "node:fs";
+import * as fs15 from "node:fs";
 import * as os10 from "node:os";
 import * as path17 from "node:path";
 var DEFAULT_MAX_BUFFER_BYTES = 50 * 1024 * 1024;
@@ -29680,7 +29713,7 @@ function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
   const homedir15 = deps.homedir ?? (() => os10.homedir());
   const baselineDir = path17.join(workspacePath, ".olam", "baseline");
   try {
-    fs14.mkdirSync(baselineDir, { recursive: true });
+    fs15.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`);
@@ -29694,7 +29727,7 @@ function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
     const filename = `${sanitizeRepoFilename(repo.name)}.diff`;
     const outPath = path17.join(baselineDir, filename);
     const repoPath = expandHome(repo.path, homedir15);
-    if (!fs14.existsSync(repoPath)) {
+    if (!fs15.existsSync(repoPath)) {
       writeBaselineFile(outPath, `# repo: ${repo.name}
 # (skipped: path ${repoPath} does not exist)
 `);
@@ -29761,7 +29794,7 @@ function snapshotBaselineDiff(repos, workspacePath, deps = {}) {
 }
 function writeBaselineFile(outPath, content) {
   try {
-    fs14.writeFileSync(outPath, content);
+    fs15.writeFileSync(outPath, content);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     console.warn(`[baseline-diff] write to ${outPath} failed: ${msg}`);
@@ -29770,7 +29803,7 @@ function writeBaselineFile(outPath, content) {
 function stripWorktreeEdits(repos, workspacePath) {
   for (const repo of repos) {
     const worktreePath = path17.join(workspacePath, repo.name);
-    if (!fs14.existsSync(worktreePath))
+    if (!fs15.existsSync(worktreePath))
       continue;
     try {
       execFileSync3("git", ["checkout", "--", "."], {
@@ -29800,12 +29833,12 @@ function formatBaselineSummary(result) {
 }
 
 // ../core/dist/world/context-injection.js
-import * as fs15 from "node:fs";
+import * as fs16 from "node:fs";
 import * as path18 from "node:path";
 function injectWorldContext(opts) {
   const { world, task, linearTicketId, claudeMdExtra, taskContext, services, pleriPlaneUrl } = opts;
   const claudeDir = path18.join(world.workspacePath, ".claude");
-  fs15.mkdirSync(claudeDir, { recursive: true });
+  fs16.mkdirSync(claudeDir, { recursive: true });
   const sections = [];
   sections.push(`# Olam World: ${world.name}`);
   sections.push("");
@@ -29966,7 +29999,7 @@ function injectWorldContext(opts) {
     sections.push("");
   }
   const content = sections.join("\n");
-  fs15.writeFileSync(path18.join(claudeDir, "CLAUDE.md"), content);
+  fs16.writeFileSync(path18.join(claudeDir, "CLAUDE.md"), content);
 }
 function formatTaskSource(ctx) {
   if (ctx.source === "linear" && ctx.ticketId) {
@@ -29982,7 +30015,7 @@ function hasPlanFile(world) {
     return false;
   const plansDir = path18.join(world.workspacePath, world.repos[0], "docs", "plans");
   try {
-    return fs15.existsSync(plansDir) && fs15.readdirSync(plansDir).length > 0;
+    return fs16.existsSync(plansDir) && fs16.readdirSync(plansDir).length > 0;
   } catch {
     return false;
   }
@@ -30544,7 +30577,7 @@ function shellQuote(s) {
 
 // ../core/dist/world/snapshot.js
 import * as crypto4 from "node:crypto";
-import * as fs16 from "node:fs";
+import * as fs17 from "node:fs";
 import * as os11 from "node:os";
 import * as path19 from "node:path";
 import { execFileSync as execFileSync4, spawn } from "node:child_process";
@@ -30559,10 +30592,10 @@ function cleanupLegacyByWorldDir(worldId) {
   const legacyDir = path19.join(snapshotsDir(), worldId);
   if (worldId === "by-workspace")
     return;
-  if (!fs16.existsSync(legacyDir))
+  if (!fs17.existsSync(legacyDir))
     return;
   try {
-    fs16.rmSync(legacyDir, { recursive: true, force: true });
+    fs17.rmSync(legacyDir, { recursive: true, force: true });
   } catch {
   }
 }
@@ -30582,10 +30615,10 @@ function hashBuffers(entries) {
 }
 function computeGemsFingerprint(repoDir, imageDigest) {
   const lockfile = path19.join(repoDir, "Gemfile.lock");
-  if (!fs16.existsSync(lockfile))
+  if (!fs17.existsSync(lockfile))
     return null;
   const entries = [
-    { path: "Gemfile.lock", content: fs16.readFileSync(lockfile) }
+    { path: "Gemfile.lock", content: fs17.readFileSync(lockfile) }
   ];
   if (imageDigest) {
     entries.push({ path: "__image_digest__", content: Buffer.from(imageDigest, "utf-8") });
@@ -30596,9 +30629,9 @@ function computeNodeFingerprint(repoDir, imageDigest) {
   const candidates = ["yarn.lock", "pnpm-lock.yaml", "package-lock.json"];
   for (const name of candidates) {
     const lockfile = path19.join(repoDir, name);
-    if (fs16.existsSync(lockfile)) {
+    if (fs17.existsSync(lockfile)) {
       const entries = [
-        { path: name, content: fs16.readFileSync(lockfile) }
+        { path: name, content: fs17.readFileSync(lockfile) }
       ];
       if (imageDigest) {
         entries.push({ path: "__image_digest__", content: Buffer.from(imageDigest, "utf-8") });
@@ -30618,17 +30651,17 @@ function unpackTarballAtomic(srcPath, destDir) {
     };
   }
   const parent = path19.dirname(destDir);
-  fs16.mkdirSync(parent, { recursive: true });
+  fs17.mkdirSync(parent, { recursive: true });
   const tmpSuffix = `.tmp-${process.pid}-${crypto4.randomBytes(4).toString("hex")}`;
   const tmpDir = `${destDir}${tmpSuffix}`;
   try {
-    fs16.mkdirSync(tmpDir, { recursive: true });
+    fs17.mkdirSync(tmpDir, { recursive: true });
     execFileSync4("tar", ["-xzf", srcPath, "-C", tmpDir], { stdio: "pipe" });
-    fs16.renameSync(tmpDir, destDir);
+    fs17.renameSync(tmpDir, destDir);
     return { ok: true, entryCount: validation.entries.length };
   } catch (err) {
     try {
-      fs16.rmSync(tmpDir, { recursive: true, force: true });
+      fs17.rmSync(tmpDir, { recursive: true, force: true });
     } catch {
     }
     return {
@@ -30694,7 +30727,7 @@ function parseTarListLine(line) {
 function validateHardlinksBinary(tarPath, targetDir) {
   let raw;
   try {
-    raw = gunzipSync(fs16.readFileSync(tarPath));
+    raw = gunzipSync(fs17.readFileSync(tarPath));
   } catch {
     return null;
   }
@@ -30800,7 +30833,7 @@ function restoreSnapshotsForRepos(input) {
       const archDir = snapshotKindDirByWorkspace(input.workspace, input.arch, kind);
       const tarFilename = `${repo.name}-${input.arch}-${fingerprint}.tar.gz`;
       const tarPath = path19.join(archDir, tarFilename);
-      if (!fs16.existsSync(tarPath)) {
+      if (!fs17.existsSync(tarPath)) {
         outcomes.push({ repo: repo.name, kind, outcome: "miss", reason: "no-tarball", fingerprint });
         continue;
       }
@@ -30817,7 +30850,7 @@ function restoreSnapshotsForRepos(input) {
       }
       const targetDir = path19.join(repo.worktreeDir, targetSubpath);
       try {
-        fs16.rmSync(targetDir, { recursive: true, force: true });
+        fs17.rmSync(targetDir, { recursive: true, force: true });
       } catch {
       }
       const result = unpackTarballAtomic(tarPath, targetDir);
@@ -30830,8 +30863,8 @@ function restoreSnapshotsForRepos(input) {
           fingerprint
         });
         try {
-          fs16.rmSync(tarPath, { force: true });
-          fs16.rmSync(manifestPath(tarPath), { force: true });
+          fs17.rmSync(tarPath, { force: true });
+          fs17.rmSync(manifestPath(tarPath), { force: true });
         } catch {
         }
         continue;
@@ -30847,10 +30880,10 @@ function restoreSnapshotsForRepos(input) {
 }
 function readManifest(tarPath) {
   const mPath = manifestPath(tarPath);
-  if (!fs16.existsSync(mPath))
+  if (!fs17.existsSync(mPath))
     return null;
   try {
-    return JSON.parse(fs16.readFileSync(mPath, "utf-8"));
+    return JSON.parse(fs17.readFileSync(mPath, "utf-8"));
   } catch {
     return null;
   }
@@ -30865,17 +30898,17 @@ function isPidAlive(pid) {
   }
 }
 function evictOldSnapshotsWithFlock(maxBytes, dir = snapshotsDir()) {
-  fs16.mkdirSync(dir, { recursive: true });
+  fs17.mkdirSync(dir, { recursive: true });
   const lockPath = path19.join(dir, EVICT_LOCK_FILENAME);
   let fd;
   try {
-    fd = fs16.openSync(lockPath, fs16.constants.O_WRONLY | fs16.constants.O_CREAT | fs16.constants.O_EXCL, 384);
+    fd = fs17.openSync(lockPath, fs17.constants.O_WRONLY | fs17.constants.O_CREAT | fs17.constants.O_EXCL, 384);
   } catch (err) {
     if (err.code !== "EEXIST")
       return 0;
     let holderPid = null;
     try {
-      holderPid = parseInt(fs16.readFileSync(lockPath, "utf-8").trim(), 10);
+      holderPid = parseInt(fs17.readFileSync(lockPath, "utf-8").trim(), 10);
     } catch {
       holderPid = null;
     }
@@ -30883,23 +30916,23 @@ function evictOldSnapshotsWithFlock(maxBytes, dir = snapshotsDir()) {
       return 0;
     }
     try {
-      fs16.unlinkSync(lockPath);
-      fd = fs16.openSync(lockPath, fs16.constants.O_WRONLY | fs16.constants.O_CREAT | fs16.constants.O_EXCL, 384);
+      fs17.unlinkSync(lockPath);
+      fd = fs17.openSync(lockPath, fs17.constants.O_WRONLY | fs17.constants.O_CREAT | fs17.constants.O_EXCL, 384);
     } catch {
       return 0;
     }
   }
   try {
-    fs16.writeSync(fd, `${process.pid}
+    fs17.writeSync(fd, `${process.pid}
 `);
   } finally {
-    fs16.closeSync(fd);
+    fs17.closeSync(fd);
   }
   try {
     return evictOldSnapshots(maxBytes, dir);
   } finally {
     try {
-      fs16.unlinkSync(lockPath);
+      fs17.unlinkSync(lockPath);
     } catch {
     }
   }
@@ -30932,16 +30965,16 @@ function spawnAutoCapture(worldId, olamBin = "olam") {
   }
 }
 function evictOldSnapshots(maxBytes, dir = snapshotsDir()) {
-  if (!fs16.existsSync(dir))
+  if (!fs17.existsSync(dir))
     return 0;
   const allTars = [];
   const walk = (d) => {
-    for (const entry of fs16.readdirSync(d, { withFileTypes: true })) {
+    for (const entry of fs17.readdirSync(d, { withFileTypes: true })) {
       const full = path19.join(d, entry.name);
       if (entry.isDirectory()) {
         walk(full);
       } else if (entry.name.endsWith(".tar.gz")) {
-        const stat = fs16.statSync(full);
+        const stat = fs17.statSync(full);
         allTars.push({ path: full, size: stat.size, mtime: stat.mtimeMs });
       }
     }
@@ -30956,8 +30989,8 @@ function evictOldSnapshots(maxBytes, dir = snapshotsDir()) {
   for (const tar of allTars) {
     if (remaining <= maxBytes)
       break;
-    fs16.rmSync(tar.path, { force: true });
-    fs16.rmSync(manifestPath(tar.path), { force: true });
+    fs17.rmSync(tar.path, { force: true });
+    fs17.rmSync(manifestPath(tar.path), { force: true });
     freed += tar.size;
     remaining -= tar.size;
   }
@@ -31095,7 +31128,7 @@ function enrichReposWithManifests(repos, workspacePath) {
 }
 
 // ../core/dist/policies/loader.js
-import * as fs17 from "node:fs";
+import * as fs18 from "node:fs";
 import * as path21 from "node:path";
 import { parse as parseYaml3 } from "yaml";
 function parseFrontmatter(content) {
@@ -31117,11 +31150,11 @@ function toStringArray(v) {
 }
 function loadPolicies(workspaceRoot) {
   const policiesDir = path21.join(workspaceRoot, ".olam", "policies");
-  if (!fs17.existsSync(policiesDir))
+  if (!fs18.existsSync(policiesDir))
     return [];
   let files;
   try {
-    files = fs17.readdirSync(policiesDir).filter((f) => f.endsWith(".md")).sort();
+    files = fs18.readdirSync(policiesDir).filter((f) => f.endsWith(".md")).sort();
   } catch {
     return [];
   }
@@ -31129,7 +31162,7 @@ function loadPolicies(workspaceRoot) {
   for (const file of files) {
     const filePath = path21.join(policiesDir, file);
     try {
-      const content = fs17.readFileSync(filePath, "utf8");
+      const content = fs18.readFileSync(filePath, "utf8");
       const parsed = parseFrontmatter(content);
       if (!parsed) {
         console.warn(`[policies] skipping ${file}: no valid frontmatter block`);
@@ -31180,7 +31213,7 @@ function formatPoliciesBrief(policies) {
 }
 
 // ../core/dist/global-config/runbook-resolver.js
-import * as fs18 from "node:fs";
+import * as fs19 from "node:fs";
 import * as os12 from "node:os";
 import * as path22 from "node:path";
 function expandTilde(p) {
@@ -31197,7 +31230,7 @@ function resolveRunbookToWorldParams(runbook, repoRegistry) {
       throw new Error(`repo "${repoName}" is referenced by runbook "${runbook.name}" but is not in the registry. Run "olam repos add ${repoName} --path <path>" to register it.`);
     }
     const resolvedPath = expandTilde(entry.path);
-    if (!fs18.existsSync(resolvedPath)) {
+    if (!fs19.existsSync(resolvedPath)) {
       throw new Error(`repo "${repoName}" path "${resolvedPath}" no longer exists. Run "olam repos update ${repoName} --path <new-path>" to fix.`);
     }
   }
@@ -31210,7 +31243,7 @@ function resolveRunbookToWorldParams(runbook, repoRegistry) {
 }
 
 // ../core/dist/world/bootstrap-hooks.js
-import * as fs19 from "node:fs";
+import * as fs20 from "node:fs";
 import * as path23 from "node:path";
 function runFixtureCopySeeds(seeds, workspacePath) {
   if (!seeds)
@@ -31221,8 +31254,8 @@ function runFixtureCopySeeds(seeds, workspacePath) {
     const srcAbs = path23.resolve(workspacePath, seed.repo, seed.src);
     const destAbs = path23.resolve(workspacePath, seed.repo, seed.dest);
     const destDir = path23.dirname(destAbs);
-    fs19.mkdirSync(destDir, { recursive: true });
-    fs19.cpSync(srcAbs, destAbs, { recursive: true, force: true });
+    fs20.mkdirSync(destDir, { recursive: true });
+    fs20.cpSync(srcAbs, destAbs, { recursive: true, force: true });
   }
 }
 async function runSeedHooks(seeds, containerName, servicePortMap, exec) {
@@ -31835,7 +31868,7 @@ ${detail}`);
         continue;
       const sourceRoot = repo.path.replace(/^~/, os13.homedir());
       const worktreeRoot = path24.join(workspacePath, repo.name);
-      if (!fs20.existsSync(sourceRoot) || !fs20.existsSync(worktreeRoot))
+      if (!fs21.existsSync(sourceRoot) || !fs21.existsSync(worktreeRoot))
         continue;
       let copied = 0;
       for (const pattern of RUNTIME_FILE_PATTERNS) {
@@ -31843,28 +31876,28 @@ ${detail}`);
         if (pattern.includes("*")) {
           const [dir, glob] = [path24.dirname(pattern), path24.basename(pattern)];
           const sourceDir = path24.join(sourceRoot, dir);
-          if (fs20.existsSync(sourceDir)) {
+          if (fs21.existsSync(sourceDir)) {
             const ext = glob.replace(/^\*+/, "");
             try {
-              for (const entry of fs20.readdirSync(sourceDir)) {
+              for (const entry of fs21.readdirSync(sourceDir)) {
                 if (ext === "" || entry.endsWith(ext))
                   matches2.push(path24.join(dir, entry));
               }
             } catch {
             }
           }
-        } else if (fs20.existsSync(path24.join(sourceRoot, pattern))) {
+        } else if (fs21.existsSync(path24.join(sourceRoot, pattern))) {
           matches2.push(pattern);
         }
         for (const rel of matches2) {
           const src = path24.join(sourceRoot, rel);
           const dst = path24.join(worktreeRoot, rel);
           try {
-            const st = fs20.statSync(src);
+            const st = fs21.statSync(src);
             if (!st.isFile())
               continue;
-            fs20.mkdirSync(path24.dirname(dst), { recursive: true });
-            fs20.copyFileSync(src, dst);
+            fs21.mkdirSync(path24.dirname(dst), { recursive: true });
+            fs21.copyFileSync(src, dst);
             copied++;
           } catch {
           }
@@ -32031,9 +32064,9 @@ ${detail}`);
       if (opts.task)
         worldEnv.OLAM_TASK = opts.task;
       const r2CredsPath = path24.join(os13.homedir(), ".olam", "r2-credentials.json");
-      if (fs20.existsSync(r2CredsPath)) {
+      if (fs21.existsSync(r2CredsPath)) {
         try {
-          const r2Raw = fs20.readFileSync(r2CredsPath, "utf-8").trim();
+          const r2Raw = fs21.readFileSync(r2CredsPath, "utf-8").trim();
           if (r2Raw.length > 0) {
             const r2 = JSON.parse(r2Raw);
             if (typeof r2.account_id === "string")
@@ -32051,9 +32084,9 @@ ${detail}`);
         }
       }
       const keysYamlPath = path24.join(os13.homedir(), ".olam", "keys.yaml");
-      if (fs20.existsSync(keysYamlPath)) {
+      if (fs21.existsSync(keysYamlPath)) {
         try {
-          const keysRaw = fs20.readFileSync(keysYamlPath, "utf-8").trim();
+          const keysRaw = fs21.readFileSync(keysYamlPath, "utf-8").trim();
           if (keysRaw.length > 0) {
             const parsed = YAML3.parse(keysRaw);
             if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
@@ -32114,8 +32147,8 @@ ${detail}`);
         for (const { repoName, relativePath, content } of fileWrites) {
           const absPath = path24.join(workspacePath, repoName, relativePath);
           try {
-            fs20.mkdirSync(path24.dirname(absPath), { recursive: true });
-            fs20.writeFileSync(absPath, content.endsWith("\n") ? content : content + "\n", {
+            fs21.mkdirSync(path24.dirname(absPath), { recursive: true });
+            fs21.writeFileSync(absPath, content.endsWith("\n") ? content : content + "\n", {
               mode: 384
             });
             console.log(`[secrets] ${repoName}: materialised ${relativePath} (${content.length} chars, mode 0600)`);
@@ -32340,7 +32373,7 @@ ${opts.task}`;
             execSync5(`docker exec ${containerName} mkdir -p /home/olam/.olam/policies`, { stdio: "pipe", timeout: 1e4 });
             for (const repo of repos) {
               const policiesDir = path24.join(workspacePath, repo.name, ".olam", "policies");
-              if (fs20.existsSync(policiesDir)) {
+              if (fs21.existsSync(policiesDir)) {
                 execSync5(`docker cp "${policiesDir}/." "${containerName}:/home/olam/.olam/policies/"`, { stdio: "pipe", timeout: 15e3 });
               }
             }
@@ -32432,8 +32465,8 @@ ${opts.task}`;
     } catch {
     }
     try {
-      fs20.rmSync(world.workspacePath, { recursive: true, force: true });
-      if (fs20.existsSync(world.workspacePath)) {
+      fs21.rmSync(world.workspacePath, { recursive: true, force: true });
+      if (fs21.existsSync(world.workspacePath)) {
         console.warn(`[WorldManager] destroyWorld(${worldId}): workspace dir ${world.workspacePath} still exists after rmSync. Run \`olam clean --apply\` to reap.`);
       }
     } catch (err) {
@@ -32506,26 +32539,50 @@ ${opts.task}`;
     if (!repoNames || repoNames.length === 0) {
       return [...this.config.repos];
     }
+    let globalRepos = [];
+    try {
+      globalRepos = readGlobalConfig().repos;
+    } catch {
+    }
     return repoNames.map((name) => {
-      const repo = this.config.repos.find((r) => r.name === name);
-      if (!repo) {
-        throw new Error(`Repo "${name}" not found in config`);
-      }
-      return repo;
+      const local = this.config.repos.find((r) => r.name === name);
+      if (local)
+        return local;
+      const globalEntry = globalRepos.find((r) => r.name === name);
+      if (globalEntry)
+        return repoEntryToRepoConfig(globalEntry);
+      throw new Error(`Repo "${name}" not found in config`);
     });
   }
   resolveReposFromNames(names) {
-    return names.map((name) => this.config.repos.find((r) => r.name === name)).filter((r) => r !== void 0);
+    let globalRepos = [];
+    try {
+      globalRepos = readGlobalConfig().repos;
+    } catch {
+    }
+    return names.map((name) => {
+      const local = this.config.repos.find((r) => r.name === name);
+      if (local)
+        return local;
+      const globalEntry = globalRepos.find((r) => r.name === name);
+      if (!globalEntry)
+        return void 0;
+      try {
+        return repoEntryToRepoConfig(globalEntry);
+      } catch {
+        return void 0;
+      }
+    }).filter((r) => r !== void 0);
   }
   transportPlanFile(planFilePath, workspacePath, repoNames) {
-    const planContent = fs20.readFileSync(planFilePath, "utf-8");
+    const planContent = fs21.readFileSync(planFilePath, "utf-8");
     const planFileName = path24.basename(planFilePath);
     const targetRepo = repoNames[0];
     if (!targetRepo)
       return;
     const plansDir = path24.join(workspacePath, targetRepo, "docs", "plans");
-    fs20.mkdirSync(plansDir, { recursive: true });
-    fs20.writeFileSync(path24.join(plansDir, planFileName), planContent);
+    fs21.mkdirSync(plansDir, { recursive: true });
+    fs21.writeFileSync(path24.join(plansDir, planFileName), planContent);
   }
   resolveServices(repos) {
     const services = [];
@@ -32610,7 +32667,7 @@ import * as http2 from "node:http";
 
 // ../core/dist/dashboard/server.js
 import * as http from "node:http";
-import * as fs21 from "node:fs";
+import * as fs22 from "node:fs";
 import * as path25 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
@@ -32946,7 +33003,7 @@ function notFound(res) {
 }
 function openThoughtStore(workspacePath) {
   const dbPath = getWorldDbPath(workspacePath);
-  if (!fs21.existsSync(dbPath))
+  if (!fs22.existsSync(dbPath))
     return null;
   return new ThoughtLocalStore(dbPath);
 }
@@ -33120,10 +33177,10 @@ function createDashboardServer(opts) {
   const thisDir = path25.dirname(fileURLToPath2(import.meta.url));
   const defaultPublicDir = path25.resolve(thisDir, "../../../control-plane/public");
   const publicDir = opts.publicDir ?? defaultPublicDir;
-  let hasPublicDir = fs21.existsSync(publicDir);
+  let hasPublicDir = fs22.existsSync(publicDir);
   const server = http.createServer((req, res) => {
     if (!hasPublicDir) {
-      hasPublicDir = fs21.existsSync(publicDir);
+      hasPublicDir = fs22.existsSync(publicDir);
     }
     const host = req.headers.host ?? `localhost:${port}`;
     const url = new URL(req.url ?? "/", `http://${host}`);
@@ -33402,17 +33459,17 @@ function createDashboardServer(opts) {
       notFound(res);
       return;
     }
-    if (fs21.existsSync(filePath) && fs21.statSync(filePath).isFile()) {
+    if (fs22.existsSync(filePath) && fs22.statSync(filePath).isFile()) {
       const ext = path25.extname(filePath);
       const contentType = MIME[ext] ?? "application/octet-stream";
       res.writeHead(200, { "Content-Type": contentType });
-      fs21.createReadStream(filePath).pipe(res);
+      fs22.createReadStream(filePath).pipe(res);
       return;
     }
     filePath = path25.join(publicDir, "index.html");
-    if (fs21.existsSync(filePath)) {
+    if (fs22.existsSync(filePath)) {
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-      fs21.createReadStream(filePath).pipe(res);
+      fs22.createReadStream(filePath).pipe(res);
       return;
     }
     notFound(res);
@@ -33422,17 +33479,17 @@ function createDashboardServer(opts) {
 }
 
 // ../core/dist/dashboard/state.js
-import * as fs22 from "node:fs";
+import * as fs23 from "node:fs";
 import * as os14 from "node:os";
 import * as path26 from "node:path";
 var STATE_PATH = path26.join(os14.homedir(), ".olam", "dashboard.json");
 function saveDashboardState(state) {
-  fs22.mkdirSync(path26.dirname(STATE_PATH), { recursive: true });
-  fs22.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2));
+  fs23.mkdirSync(path26.dirname(STATE_PATH), { recursive: true });
+  fs23.writeFileSync(STATE_PATH, JSON.stringify(state, null, 2));
 }
 function loadDashboardState() {
   try {
-    const raw = fs22.readFileSync(STATE_PATH, "utf-8");
+    const raw = fs23.readFileSync(STATE_PATH, "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -33440,7 +33497,7 @@ function loadDashboardState() {
 }
 function clearDashboardState() {
   try {
-    fs22.unlinkSync(STATE_PATH);
+    fs23.unlinkSync(STATE_PATH);
   } catch {
   }
 }
@@ -33720,7 +33777,7 @@ var PleriClient = class {
 };
 
 // ../mcp-server/src/env-loader.ts
-import { readFileSync as readFileSync16, existsSync as existsSync21, statSync as statSync7 } from "node:fs";
+import { readFileSync as readFileSync16, existsSync as existsSync22, statSync as statSync7 } from "node:fs";
 import { join as join27, dirname as dirname15, resolve as resolve7 } from "node:path";
 var PROJECT_MARKERS = [
   ".olam/config.yaml",
@@ -33733,10 +33790,10 @@ function findProjectRoot2(startDir) {
   const root = resolve7("/");
   while (true) {
     for (const marker of PROJECT_MARKERS) {
-      if (existsSync21(join27(dir, marker))) return dir;
+      if (existsSync22(join27(dir, marker))) return dir;
     }
     const pkg = join27(dir, "package.json");
-    if (existsSync21(pkg)) {
+    if (existsSync22(pkg)) {
       try {
         const json = JSON.parse(readFileSync16(pkg, "utf8"));
         const isOlamWorkspace = typeof json.name === "string" && json.name.startsWith("@olam/");
@@ -33776,7 +33833,7 @@ function loadProjectEnv(startDir = process.cwd()) {
   const merged = {};
   for (const name of [".env", ".env.local"]) {
     const p = join27(root, name);
-    if (existsSync21(p) && statSync7(p).isFile()) {
+    if (existsSync22(p) && statSync7(p).isFile()) {
       Object.assign(merged, parseEnvFile(p));
       filesRead.push(p);
     }