@pleri/olam-cli 0.1.182 → 0.1.186

package/dist/mcp-server.js

@@ -13373,7 +13373,7 @@ var init_artifact_resolver = __esm({
 
 // ../core/dist/lib/shim-targets.js
 function lookupShimTarget(basename6) {
-  return SHIM_TARGETS.find((t) => t.basename === basename6);
+  return SHIM_TARGETS_BY_BASENAME.get(basename6);
 }
 function compareSemver(installed, required2) {
   const norm = (s) => {
@@ -13404,7 +13404,7 @@ function checkShimRemoval(basename6, installedOlamVersion) {
     safeToRemove: compareSemver(installedOlamVersion, target.minOlamVersion) >= 0
   };
 }
-var SHIM_TARGETS;
+var SHIM_TARGETS, SHIM_TARGETS_BY_BASENAME;
 var init_shim_targets = __esm({
   "../core/dist/lib/shim-targets.js"() {
     "use strict";
@@ -13419,6 +13419,7 @@ var init_shim_targets = __esm({
       { basename: "apply-overlays.py", minOlamVersion: "0.2.0", replacedBy: "olam skills apply-overlays" },
       { basename: "sync-with-overlays.sh", minOlamVersion: "0.2.0", replacedBy: "olam skills sync --with-overlays" }
     ]);
+    SHIM_TARGETS_BY_BASENAME = new Map(SHIM_TARGETS.map((t) => [t.basename, t]));
   }
 });
 
@@ -14845,19 +14846,28 @@ function parseSections(body) {
   return sections;
 }
 function sectionsToBody(sections) {
+  let tail = "";
   const out = [];
+  function trackPush(s) {
+    out.push(s);
+    if (s.length >= 2) {
+      tail = s.slice(-2);
+    } else if (s.length === 1) {
+      tail = (tail.length > 0 ? tail.slice(-1) : "") + s;
+    }
+  }
   for (const [heading, content] of sections) {
     if (heading === null) {
-      out.push(content);
+      trackPush(content);
     } else {
-      const current = out.join("");
-      if (current !== "" && !current.endsWith("\n\n")) {
-        if (current.endsWith("\n"))
-          out.push("\n");
+      const hasOutput = out.length > 0 && (out.length > 1 || out[0] !== "");
+      if (hasOutput && tail !== "\n\n") {
+        if (tail.endsWith("\n"))
+          trackPush("\n");
         else
-          out.push("\n\n");
+          trackPush("\n\n");
       }
-      out.push(heading + content);
+      trackPush(heading + content);
     }
   }
   return out.join("");
@@ -32042,12 +32052,28 @@ function rowToEdge(row) {
 var SCHEMA_VERSION2 = "2";
 var ThoughtLocalStore = class {
   db;
+  // Prepared statements cached at construction time so insertNode / insertEdge
+  // never re-compile the same SQL on every call in a hot insertBatch loop.
+  stmtInsertNode;
+  stmtInsertEdge;
   constructor(dbPath) {
     const Database = getDatabase2();
     this.db = new Database(dbPath);
     this.db.pragma("journal_mode = WAL");
     this.db.pragma("foreign_keys = ON");
     this.initSchema();
+    this.stmtInsertNode = this.db.prepare(`
+      INSERT INTO thought_nodes (id, node_type, summary, content, source_ref, sequence_num, created_at,
+                                 session_id, hook_event_name, turn_index, token_usage, duration_ms)
+      VALUES (@id, @nodeType, @summary, @content, @sourceRef, @sequenceNum, @createdAt,
+              @sessionId, @hookEventName, @turnIndex, @tokenUsage, @durationMs)
+      ON CONFLICT (id) DO NOTHING
+    `);
+    this.stmtInsertEdge = this.db.prepare(`
+      INSERT INTO thought_edges (id, source_id, target_id, edge_type, metadata, created_at)
+      VALUES (@id, @sourceId, @targetId, @edgeType, @metadata, @createdAt)
+      ON CONFLICT (id) DO NOTHING
+    `);
   }
   initSchema() {
     this.db.exec(`
@@ -32145,14 +32171,7 @@ var ThoughtLocalStore = class {
     migrate();
   }
   insertNode(node) {
-    const stmt = this.db.prepare(`
-      INSERT INTO thought_nodes (id, node_type, summary, content, source_ref, sequence_num, created_at,
-                                 session_id, hook_event_name, turn_index, token_usage, duration_ms)
-      VALUES (@id, @nodeType, @summary, @content, @sourceRef, @sequenceNum, @createdAt,
-              @sessionId, @hookEventName, @turnIndex, @tokenUsage, @durationMs)
-      ON CONFLICT (id) DO NOTHING
-    `);
-    stmt.run({
+    this.stmtInsertNode.run({
       id: node.id,
       nodeType: node.nodeType,
       summary: node.summary,
@@ -32168,12 +32187,7 @@ var ThoughtLocalStore = class {
     });
   }
   insertEdge(edge) {
-    const stmt = this.db.prepare(`
-      INSERT INTO thought_edges (id, source_id, target_id, edge_type, metadata, created_at)
-      VALUES (@id, @sourceId, @targetId, @edgeType, @metadata, @createdAt)
-      ON CONFLICT (id) DO NOTHING
-    `);
-    stmt.run({
+    this.stmtInsertEdge.run({
       id: edge.id,
       sourceId: edge.sourceId,
       targetId: edge.targetId,
@@ -37832,6 +37846,152 @@ function register31(server, _ctx, _initError) {
   );
 }
 
+// ../mcp-server/src/tools/pr-apply-review-comments.ts
+var pr_apply_review_comments_exports = {};
+__export(pr_apply_review_comments_exports, {
+  register: () => register32
+});
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+
+// ../skill-runtime/dist/skills/pr-apply-review-comments.js
+init_v3();
+var prApplyReviewCommentsInputSchema = external_exports.object({
+  prNumber: external_exports.number().int().positive().describe("GitHub PR number to fetch unresolved review threads from"),
+  dryRun: external_exports.boolean().optional().describe("When true (default), return what would be dispatched without firing. v1 always dry-runs regardless of this flag \u2014 dispatch wiring is Phase 2."),
+  repo: external_exports.string().optional().describe("Repository slug (owner/repo). Defaults to the current repo detected via git remote.")
+});
+var prApplyReviewCommentsSkill = defineSkill({
+  name: "pr-apply-review-comments",
+  description: "Fetch unresolved review-comment threads for a GitHub PR and package them as an Olam dispatch payload. Returns the PR metadata, a structured comment list, and the synthesised prompt that would be dispatched. v1 stub \u2014 dispatch is NOT wired (Phase 2). Safe to call from any agent; nothing is mutated or fired.",
+  inputSchema: prApplyReviewCommentsInputSchema,
+  handler: (input) => {
+    return {
+      pr: {
+        number: input.prNumber,
+        title: "(skill-runtime stub \u2014 no gh context)",
+        headRefName: "stub-branch"
+      },
+      comments: [],
+      dispatchPayload: {
+        worldId: null,
+        prompt: `Apply review comments on PR #${input.prNumber}.
+(No comments resolved \u2014 skill-runtime stub context.)`
+      },
+      status: "dry-run",
+      stubNote: "v1 stub: skill-runtime handler has no gh context. Register this skill via @olam/mcp-server for a live response."
+    };
+  }
+});
+
+// ../mcp-server/src/tools/pr-apply-review-comments.ts
+var execFileAsync = promisify2(execFile2);
+function resolveWorldId(_prNumber) {
+  return null;
+}
+function synthesisePrompt(prNumber, comments) {
+  if (comments.length === 0) {
+    return `No unresolved review comments found on PR #${prNumber}. Nothing to apply.`;
+  }
+  const lines = [
+    `Apply all unresolved reviewer comments on PR #${prNumber}.`,
+    ``,
+    `Unresolved review comments (${comments.length}):`
+  ];
+  for (const c of comments) {
+    const location = c.line != null ? `${c.path}:${c.line}` : c.path;
+    lines.push(`- [${location}] @${c.author}: ${c.body.replace(/\n/g, " ").slice(0, 200)}`);
+  }
+  lines.push(
+    ``,
+    `For each comment: understand the reviewer's intent, make the minimal change`,
+    `that addresses it, then move on. Do not introduce scope beyond what each`,
+    `comment requests. Push when all comments are addressed.`
+  );
+  return lines.join("\n");
+}
+async function fetchPrData(prNumber, repo) {
+  const args = [
+    "pr",
+    "view",
+    String(prNumber),
+    "--json",
+    "number,title,headRefName,reviewThreads"
+  ];
+  if (repo) {
+    args.push("--repo", repo);
+  }
+  const { stdout } = await execFileAsync("gh", args, {
+    timeout: 15e3
+  });
+  return JSON.parse(stdout);
+}
+function register32(server, _ctx, _initError, deps) {
+  const fetcher = deps?.fetchPr ?? fetchPrData;
+  const { description, inputSchema } = prApplyReviewCommentsSkill.asMcpTool();
+  server.tool(
+    "olam_pr_apply_review_comments",
+    description,
+    inputSchema,
+    async (params) => {
+      const { prNumber, repo } = params;
+      let prData;
+      try {
+        prData = await fetcher(prNumber, repo);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to fetch PR #${prNumber}: ${msg}
+
+Ensure gh CLI is authenticated and the PR exists.`
+            }
+          ],
+          isError: true
+        };
+      }
+      const unresolvedThreads = (prData.reviewThreads ?? []).filter(
+        (t) => !t.isResolved && !t.isOutdated
+      );
+      const comments = unresolvedThreads.flatMap(
+        (thread) => (thread.comments.nodes ?? []).map((node) => ({
+          author: node.author?.login ?? "unknown",
+          body: node.body,
+          path: node.path,
+          line: node.line ?? node.originalLine ?? null,
+          threadId: thread.id
+        }))
+      );
+      const worldId = resolveWorldId(prNumber);
+      const prompt = synthesisePrompt(prNumber, comments);
+      const result = {
+        pr: {
+          number: prData.number,
+          title: prData.title,
+          headRefName: prData.headRefName
+        },
+        comments,
+        dispatchPayload: {
+          worldId,
+          prompt
+        },
+        status: "dry-run",
+        stubNote: "v1 stub: dispatch is not wired. Phase 2 will wire worldId resolution + actual olam_dispatch call. See docs/research/2026-05-27-pr-comment-reply-prior-art.md for the shaping brief."
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
 // ../mcp-server/src/tools/index.ts
 var toolModules = [
   init_exports,
@@ -37864,7 +38024,8 @@ var toolModules = [
   kg_classify_exports,
   kg_doctor_exports,
   kg_install_hook_exports,
-  kg_uninstall_hook_exports
+  kg_uninstall_hook_exports,
+  pr_apply_review_comments_exports
 ];
 function registerAllTools(server, ctx, initError) {
   const filterContext = getToolFilterContextFromEnv();
@@ -38202,6 +38363,374 @@ function createChunksResource(deps = {}) {
   };
 }
 
+// ../mcp-server/src/resources/capabilities.ts
+var CAPABILITIES_URI = "olam://capabilities";
+var CHUNKS_ERROR_CODES = [
+  {
+    code: "invalid_uri",
+    jsonRpcCode: -32602,
+    jsonRpcClass: "InvalidParams",
+    when: "URI scheme/host/path does not match olam://worlds/<id>/chunks."
+  },
+  {
+    code: "missing_session_id",
+    jsonRpcCode: -32602,
+    jsonRpcClass: "InvalidParams",
+    when: "URI lacks ?sessionId=... \u2014 the Electric shape proxy requires it."
+  },
+  {
+    code: "missing_bearer",
+    jsonRpcCode: -32602,
+    jsonRpcClass: "InvalidParams",
+    when: "Neither OLAM_PLAN_CHAT_BEARER nor the on-disk secret is readable."
+  },
+  {
+    code: "upstream_unavailable",
+    jsonRpcCode: -32603,
+    jsonRpcClass: "InternalError",
+    when: "host-cp /api/plan-chat/v1/shape unreachable (fetch threw)."
+  },
+  {
+    code: "upstream_error",
+    jsonRpcCode: -32603,
+    jsonRpcClass: "InternalError",
+    when: "host-cp returned a non-2xx or non-JSON body."
+  }
+];
+function buildCapabilitiesPayload(chunks) {
+  return {
+    schemaVersion: 1,
+    server: "olam",
+    capabilities: { resources: true, tools: true },
+    resources: [
+      {
+        name: chunks.name,
+        uriTemplate: chunks.uriTemplate,
+        templated: true,
+        mimeType: chunks.mimeType,
+        description: chunks.description,
+        params: [
+          {
+            name: "sessionId",
+            required: true,
+            description: "Scopes the read to a single planning session. Electric SQL enforces per-(world_id,session_id) scope server-side, so this is required at read time despite being optional in the template."
+          },
+          {
+            name: "limit",
+            required: false,
+            description: "Advisory cap on returned row count. Parsed from the URL; not part of the matched RFC 6570 template."
+          }
+        ],
+        errorCodes: [...CHUNKS_ERROR_CODES]
+      }
+    ]
+  };
+}
+function createCapabilitiesResource() {
+  return {
+    name: "olam-capabilities",
+    uri: CAPABILITIES_URI,
+    description: "Machine-readable catalog of the Olam MCP server's Resources surface: every resource URI template, its query params, and the structured error-code taxonomy a failed resources/read can return. Read this once to discover the contract programmatically instead of parsing prose.",
+    mimeType: "application/json",
+    read(chunks) {
+      return buildCapabilitiesPayload(chunks);
+    }
+  };
+}
+
+// ../mcp-server/src/tool-catalog.ts
+function unwrap(schema) {
+  let current = schema;
+  let optional2 = false;
+  let hasDefault = false;
+  for (let depth = 0; depth < 16; depth += 1) {
+    const typeName = current._def?.typeName;
+    if (typeName === "ZodOptional") {
+      optional2 = true;
+      const inner = current._def?.innerType;
+      if (!inner) break;
+      current = inner;
+      continue;
+    }
+    if (typeName === "ZodDefault") {
+      optional2 = true;
+      hasDefault = true;
+      const inner = current._def?.innerType;
+      if (!inner) break;
+      current = inner;
+      continue;
+    }
+    if (typeName === "ZodNullable") {
+      const inner = current._def?.innerType;
+      if (!inner) break;
+      current = inner;
+      continue;
+    }
+    if (typeName === "ZodEffects") {
+      const inner = current._def?.schema;
+      if (!inner) break;
+      current = inner;
+      continue;
+    }
+    break;
+  }
+  return { base: current, optional: optional2, hasDefault };
+}
+function extractDescription(schema) {
+  let current = schema;
+  for (let depth = 0; depth < 16 && current; depth += 1) {
+    const d = current._def?.description ?? current.description;
+    if (typeof d === "string" && d.length > 0) return d;
+    current = current._def?.innerType ?? current._def?.schema;
+  }
+  return null;
+}
+function canonicalType(base) {
+  const typeName = base._def?.typeName;
+  switch (typeName) {
+    case "ZodString":
+      return "string";
+    case "ZodNumber":
+      return "number";
+    case "ZodBoolean":
+      return "boolean";
+    case "ZodArray":
+      return "array";
+    case "ZodObject":
+      return "object";
+    case "ZodEnum":
+    case "ZodNativeEnum":
+      return "enum";
+    case "ZodEffects":
+      return "effect";
+    case "ZodLiteral":
+      return "literal";
+    default:
+      return typeName ? typeName.replace(/^Zod/, "").toLowerCase() : "unknown";
+  }
+}
+function readEnumValues(base) {
+  if (base._def?.typeName !== "ZodEnum" && base._def?.typeName !== "ZodNativeEnum") {
+    return null;
+  }
+  const values = base._def?.values;
+  if (Array.isArray(values)) {
+    return [...values.map((v) => String(v))].sort();
+  }
+  if (values && typeof values === "object") {
+    return Object.values(values).map((v) => String(v)).sort();
+  }
+  return null;
+}
+function isConstrained(base) {
+  const typeName = base._def?.typeName;
+  if (typeName === "ZodEnum" || typeName === "ZodNativeEnum" || typeName === "ZodNumber" || typeName === "ZodBoolean" || typeName === "ZodLiteral" || typeName === "ZodArray" || typeName === "ZodObject" || typeName === "ZodEffects") {
+    return true;
+  }
+  if (typeName === "ZodString") {
+    const checks = base._def?.checks;
+    return Array.isArray(checks) && checks.length > 0;
+  }
+  return false;
+}
+function describeParam(schema) {
+  const { base, optional: optional2, hasDefault } = unwrap(schema);
+  return {
+    type: canonicalType(base),
+    optional: optional2,
+    hasDefault,
+    description: extractDescription(schema),
+    enumValues: readEnumValues(base),
+    constrained: isConstrained(base)
+  };
+}
+function extractToolCatalog() {
+  const captured = [];
+  const recordingServer = {
+    tool(name, description, inputSchema, _handler) {
+      const params = {};
+      if (inputSchema && typeof inputSchema === "object") {
+        for (const [key, fieldSchema] of Object.entries(inputSchema)) {
+          params[key] = describeParam(fieldSchema);
+        }
+      }
+      captured.push({ name, description: description ?? "", params });
+    }
+  };
+  registerAllTools(recordingServer, void 0, void 0);
+  return [...captured].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+// ../mcp-server/src/resources/tools-catalog.ts
+var TOOLS_CATALOG_URI = "olam://tools";
+function buildToolsCatalogPayload(catalog) {
+  const tools = catalog.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    params: Object.entries(tool.params).map(([name, p]) => ({
+      name,
+      type: p.type,
+      optional: p.optional,
+      hasDefault: p.hasDefault,
+      constrained: p.constrained,
+      enumValues: p.enumValues,
+      description: p.description
+    }))
+  }));
+  return {
+    schemaVersion: 1,
+    server: "olam",
+    toolCount: tools.length,
+    tools
+  };
+}
+function createToolsCatalogResource(deps = {}) {
+  const extract = deps.extract ?? extractToolCatalog;
+  let cachedPayload = null;
+  return {
+    name: "olam-tools",
+    uri: TOOLS_CATALOG_URI,
+    description: "Machine-readable catalog of the Olam MCP server's Tools surface: every tool name, its description, and per-param metadata (type, required/optional, default, enum members, and whether the value space is constrained vs free-form). Read this once to discover which tool params are closed enum sets and which are required, so an autonomous client can build valid tool calls on the first attempt instead of inferring the contract from raw JSON Schema or hitting validation errors.",
+    mimeType: "application/json",
+    read() {
+      if (cachedPayload === null) {
+        cachedPayload = buildToolsCatalogPayload(extract());
+      }
+      return cachedPayload;
+    }
+  };
+}
+
+// ../mcp-server/src/server-identity.ts
+var SERVER_NAME = "olam";
+var SERVER_VERSION = "0.1.0";
+var SERVER_INSTRUCTIONS = [
+  "Olam manages isolated development worlds. Use olam_list_worlds to see available worlds.",
+  "Use olam_create_world to provision a new world. Use olam_dispatch to send tasks.",
+  "Use olam_observe to watch a world's reasoning. Use olam_crystallize to save thoughts.",
+  "Always olam_destroy_world when done to clean up resources."
+].join("\n");
+
+// ../mcp-server/src/resources/server-info.ts
+var SERVER_INFO_URI = "olam://server-info";
+function buildServerInfoPayload(sources) {
+  const baseEntries = [
+    {
+      name: sources.chunks.name,
+      uri: sources.chunks.uriTemplate,
+      templated: true,
+      mimeType: sources.chunks.mimeType
+    },
+    {
+      name: sources.capabilities.name,
+      uri: sources.capabilities.uri,
+      templated: false,
+      mimeType: sources.capabilities.mimeType
+    },
+    {
+      name: sources.toolsCatalog.name,
+      uri: sources.toolsCatalog.uri,
+      templated: false,
+      mimeType: sources.toolsCatalog.mimeType
+    },
+    {
+      name: SERVER_INFO_NAME,
+      uri: SERVER_INFO_URI,
+      templated: false,
+      mimeType: SERVER_INFO_MIME_TYPE
+    }
+  ];
+  if (sources.runbookManifest) {
+    baseEntries.push({
+      name: sources.runbookManifest.name,
+      uri: sources.runbookManifest.uriTemplate,
+      templated: true,
+      mimeType: sources.runbookManifest.mimeType
+    });
+  }
+  const entries = baseEntries.sort((a, b) => a.name.localeCompare(b.name));
+  return {
+    schemaVersion: 1,
+    name: SERVER_NAME,
+    version: SERVER_VERSION,
+    instructions: SERVER_INSTRUCTIONS,
+    capabilities: { resources: true, tools: true },
+    resources: entries
+  };
+}
+var SERVER_INFO_NAME = "olam-server-info";
+var SERVER_INFO_MIME_TYPE = "application/json";
+function createServerInfoResource() {
+  return {
+    name: SERVER_INFO_NAME,
+    uri: SERVER_INFO_URI,
+    description: "Machine-readable identity of the Olam MCP server: its name, version, the operator instructions advertised in the initialize handshake (re-readable here mid-session), the MCP capability flags, and a flat index of EVERY registered resource URI (templated and static, including the introspection resources). Read this first to learn what version you are talking to and the complete set of resource URIs you can read next.",
+    mimeType: SERVER_INFO_MIME_TYPE,
+    read(sources) {
+      return buildServerInfoPayload(sources);
+    }
+  };
+}
+
+// ../mcp-server/src/resources/runbook-manifest.ts
+init_global_config();
+var RUNBOOK_MANIFEST_URI_TEMPLATE = "olam://runbooks/{name}";
+var RUNBOOK_MANIFEST_NAME = "olam-runbook-manifest";
+var RUNBOOK_MANIFEST_MIME_TYPE = "application/json";
+function parseRunbookManifestUri(uri) {
+  let parsed;
+  try {
+    parsed = new URL(uri);
+  } catch {
+    return null;
+  }
+  if (parsed.protocol !== "olam:") return null;
+  if (parsed.hostname !== "runbooks") return null;
+  const name = parsed.pathname.slice(1);
+  if (!name || name.includes("/")) return null;
+  return decodeURIComponent(name);
+}
+function createRunbookManifestResource(deps = {}) {
+  const listFn = deps.listFn ?? listRunbooks;
+  const getFn = deps.getFn ?? ((name) => {
+    return getRunbook(name);
+  });
+  return {
+    name: RUNBOOK_MANIFEST_NAME,
+    uriTemplate: RUNBOOK_MANIFEST_URI_TEMPLATE,
+    description: "Machine-readable manifest of a registered Olam runbook: its repos, portMap, seeds, env, and description. URI: olam://runbooks/{name}. Substitute {name} with an exact runbook name (use olam_runbook_list or the resources/list snapshot to discover names). Read this to inspect a runbook before applying it \u2014 equivalent to olam_runbook_show but accessible as a Resource for context-injection workflows.",
+    mimeType: RUNBOOK_MANIFEST_MIME_TYPE,
+    read(uri) {
+      const name = parseRunbookManifestUri(uri);
+      if (!name) {
+        return {
+          ok: false,
+          code: "invalid_uri",
+          message: `Invalid runbook manifest URI "${uri}". Expected format: olam://runbooks/<name> (e.g. olam://runbooks/node-devbox).`
+        };
+      }
+      try {
+        const manifest = getFn(name);
+        return { ok: true, uri, manifest };
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        return {
+          ok: false,
+          code: "runbook_not_found",
+          message: `Runbook "${name}" not found: ${detail}`
+        };
+      }
+    },
+    list() {
+      try {
+        return listFn().map((r) => r.name);
+      } catch {
+        return [];
+      }
+    }
+  };
+}
+
 // ../mcp-server/src/resources/index.ts
 var JSON_RPC_CODE_FOR = {
   invalid_uri: ErrorCode.InvalidParams,
@@ -38212,6 +38741,10 @@ var JSON_RPC_CODE_FOR = {
 };
 function registerAllResources(server, deps = {}) {
   const chunks = deps.chunks ?? createChunksResource();
+  const capabilities = deps.capabilities ?? createCapabilitiesResource();
+  const toolsCatalog = deps.toolsCatalog ?? createToolsCatalogResource();
+  const serverInfo = deps.serverInfo ?? createServerInfoResource();
+  const runbookManifest = deps.runbookManifest ?? createRunbookManifestResource();
   server.registerResource(
     chunks.name,
     new ResourceTemplate(chunks.uriTemplate, {
@@ -38256,21 +38789,587 @@ function registerAllResources(server, deps = {}) {
       };
     }
   );
+  server.registerResource(
+    capabilities.name,
+    capabilities.uri,
+    {
+      description: capabilities.description,
+      mimeType: capabilities.mimeType
+    },
+    async (uri) => {
+      const payload = capabilities.read(chunks);
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: capabilities.mimeType,
+            text: JSON.stringify(payload, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    toolsCatalog.name,
+    toolsCatalog.uri,
+    {
+      description: toolsCatalog.description,
+      mimeType: toolsCatalog.mimeType
+    },
+    async (uri) => {
+      const payload = toolsCatalog.read();
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: toolsCatalog.mimeType,
+            text: JSON.stringify(payload, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    serverInfo.name,
+    serverInfo.uri,
+    {
+      description: serverInfo.description,
+      mimeType: serverInfo.mimeType
+    },
+    async (uri) => {
+      const payload = serverInfo.read({
+        chunks,
+        capabilities,
+        toolsCatalog,
+        runbookManifest
+      });
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: serverInfo.mimeType,
+            text: JSON.stringify(payload, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.registerResource(
+    runbookManifest.name,
+    new ResourceTemplate(runbookManifest.uriTemplate, {
+      list: void 0
+    }),
+    {
+      description: runbookManifest.description,
+      mimeType: runbookManifest.mimeType
+    },
+    async (uri) => {
+      const result = runbookManifest.read(uri.toString());
+      if (!result.ok) {
+        const rpcCode = result.code === "invalid_uri" ? ErrorCode.InvalidParams : ErrorCode.InternalError;
+        throw new McpError(rpcCode, result.message, { code: result.code });
+      }
+      return {
+        contents: [
+          {
+            uri: result.uri,
+            mimeType: RUNBOOK_MANIFEST_MIME_TYPE,
+            text: JSON.stringify(result.manifest, null, 2)
+          }
+        ]
+      };
+    }
+  );
   logger.info("Olam MCP resources registered", {
-    resources: [chunks.name],
-    uriTemplate: chunks.uriTemplate
+    resources: [
+      chunks.name,
+      capabilities.name,
+      toolsCatalog.name,
+      serverInfo.name,
+      runbookManifest.name
+    ],
+    uriTemplate: chunks.uriTemplate,
+    runbookManifestUriTemplate: runbookManifest.uriTemplate,
+    capabilitiesUri: capabilities.uri,
+    toolsCatalogUri: toolsCatalog.uri,
+    serverInfoUri: serverInfo.uri
+  });
+}
+
+// ../mcp-server/src/prompts/index.ts
+init_v3();
+
+// ../mcp-server/src/prompts/workflows.ts
+var INSPECT_REASONING_PROMPT_NAME = "olam-inspect-reasoning";
+var DISPATCH_FROM_RUNBOOK_PROMPT_NAME = "olam-dispatch-from-runbook";
+var DESTROY_WORLD_PROMPT_NAME = "olam-destroy-world";
+var ROTATE_AUTH_PROMPT_NAME = "olam-rotate-auth";
+var SCAFFOLD_RUNBOOK_PROMPT_NAME = "olam-scaffold-runbook";
+var TRIAGE_FAILING_WORLD_PROMPT_NAME = "olam-triage-failing-world";
+var CREATE_WORLD_FOR_LINEAR_ISSUE_PROMPT_NAME = "olam-create-world-for-linear-issue";
+var REVIEW_PR_GATE_PROMPT_NAME = "olam-review-pr-gate";
+var PROMOTE_TO_LANE_PROMPT_NAME = "olam-promote-to-lane";
+function buildInspectReasoningPrompt(args) {
+  const { worldId, sessionId } = args;
+  const chunksUri = sessionId ? `olam://worlds/${worldId}/chunks?sessionId=${sessionId}` : `olam://worlds/${worldId}/chunks?sessionId=<SESSION_ID>`;
+  const sessionGuidance = sessionId ? `The session is "${sessionId}", so read \`${chunksUri}\` directly.` : `No session was supplied. The chunks Resource REQUIRES a sessionId at read time (the Electric shape proxy enforces per-(world,session) scope and returns the \`missing_session_id\` error code otherwise). Discover the active session via olam_status or olam_observe first, then read \`${chunksUri}\` with the real id.`;
+  const text = [
+    `Inspect the reasoning stream of Olam world "${worldId}".`,
+    "",
+    "Follow this sequence:",
+    `1. Confirm the world exists and is live: call olam_status with worldId="${worldId}" (use olam_list if you need to discover worldIds \u2014 do not guess).`,
+    `2. Read the substrate-grade chunk stream via the MCP Resource \`olam://worlds/${worldId}/chunks{?sessionId}\`. ${sessionGuidance}`,
+    "3. For an incremental live tail rather than a snapshot, call olam_observe with the same worldId; pass sinceChunkId as a cursor to page forward without re-reading earlier chunks.",
+    "",
+    "Then summarise what the world is currently reasoning about, any blockers it has surfaced, and whether it appears to be making progress."
+  ].join("\n");
+  return {
+    description: `Inspect the reasoning stream of Olam world "${worldId}".`,
+    messages: [{ role: "user", content: { type: "text", text } }]
+  };
+}
+function buildDispatchFromRunbookPrompt(args) {
+  const { worldId, runbookName, task } = args;
+  const text = [
+    `Dispatch a task into Olam world "${worldId}" after preparing it with the "${runbookName}" runbook.`,
+    "",
+    "Follow this sequence:",
+    `1. Inspect the runbook so you know what it sets up: call olam_runbook_show with name="${runbookName}". If it does not exist, list options with olam_runbook_list and stop \u2014 do not invent a runbook.`,
+    `2. Confirm the target world is live: olam_status with worldId="${worldId}" (discover worldIds with olam_list if needed).`,
+    `3. Apply the runbook to the world: olam_runbook_apply with name="${runbookName}" and worldId="${worldId}".`,
+    `4. Dispatch the task: olam_dispatch with worldId="${worldId}" and prompt="${task}".`,
+    "5. Confirm the agent picked the task up: olam_observe with the same worldId and report the first few reasoning chunks.",
+    "",
+    "If any step fails, stop and report which step failed and the error \u2014 do not proceed to a later step on a failed precondition."
+  ].join("\n");
+  return {
+    description: `Prepare world "${worldId}" with runbook "${runbookName}", then dispatch a task.`,
+    messages: [{ role: "user", content: { type: "text", text } }]
+  };
+}
+function buildDestroyWorldPrompt(args) {
+  const { worldName } = args;
+  const text = [
+    `Safely destroy the Olam world whose human-readable name matches "${worldName}".`,
+    "",
+    "Follow this sequence:",
+    `1. Discover the worldId: call olam_list and find the entry whose name contains "${worldName}". If multiple worlds match, list them and ask which to destroy \u2014 do not guess.`,
+    `2. Confirm current state: call olam_status with the matched worldId. If the world is still "running" with active work (thoughtCount recently incremented or status is "dispatching"), warn that it is mid-task before proceeding.`,
+    `3. Destroy the world: call olam_destroy with the resolved worldId.`,
+    `4. Confirm destruction: report the world's name and id, and note that all its resources have been cleaned up.`,
+    "",
+    "If no world matches the name, report that clearly \u2014 do not fabricate a worldId.",
+    "If the destroy call fails, report the error verbatim and stop."
+  ].join("\n");
+  return {
+    description: `Discover and safely destroy the Olam world named "${worldName}".`,
+    messages: [{ role: "user", content: { type: "text", text } }]
+  };
+}
+function buildRotateAuthPrompt(args) {
+  const { accountLabel, provider } = args;
+  const labelText = accountLabel ?? "a new account";
+  const labelArg = accountLabel ?? "<label>";
+  const providerText = provider ?? "claude";
+  const text = [
+    `Rotate (or add) a Claude credential for ${labelText} using the "${providerText}" provider.`,
+    "",
+    "Follow this sequence:",
+    "1. Check current auth state: call olam_auth_status.",
+    `   - If the container is not running, continue to step 2.`,
+    `   - If an account labelled "${labelArg}" already shows "valid", confirm with the operator before replacing it.`,
+    "2. Ensure the auth container is up: call olam_auth_up. It is idempotent \u2014 safe to call even if already running.",
+    `3. Start the PKCE login: call olam_auth_login with label="${labelArg}" and provider="${providerText}".`,
+    `   The response contains a loginUrl and a state token. IMPORTANT: surface the loginUrl to the operator and capture the state token \u2014 you will need it in the next step.`,
+    "4. Wait for the operator to complete the browser flow and provide the authorization code.",
+    `5. Complete the exchange: call olam_auth_complete with the state token from step 3 and the code the operator just provided.`,
+    `6. Confirm: call olam_auth_status again and report the new account's flag (should be "valid") and expiry.`,
+    "",
+    "If any step fails, report the error verbatim and stop \u2014 do not proceed with a missing or invalid state token."
+  ].join("\n");
+  return {
+    description: `Rotate or add a Claude credential for ${labelText}.`,
+    messages: [{ role: "user", content: { type: "text", text } }]
+  };
+}
+function buildScaffoldRunbookPrompt(args) {
+  const { runbookName, repos, description, templateWorldId } = args;
+  const repoList = repos.join(", ");
+  const descText = description ?? `Runbook for ${repoList}`;
+  const templateClause = templateWorldId ? `Before calling olam_runbook_add, inspect the live world "${templateWorldId}" with olam_status to borrow its portOffset as a portMap baseline: use portOffset as the base and assign service ports relative to it (e.g. portOffset + 0 for the primary service, + 1 for the secondary). ` : `If you have a reference world whose port layout matches what this runbook needs, consult its portOffset first. Otherwise omit portMap and rely on Olam's automatic assignment. `;
+  const text = [
+    `Scaffold a new Olam runbook named "${runbookName}" covering repos: ${repoList}.`,
+    "",
+    "Follow this sequence:",
+    `1. Check for a name collision: call olam_runbook_list. If "${runbookName}" already exists, stop and report it \u2014 do not overwrite without explicit operator confirmation.`,
+    `2. ${templateClause}`,
+    `3. Call olam_runbook_add with this payload shape:`,
+    `   - name: "${runbookName}"`,
+    `   - repos: [${repos.map((r) => `"${r}"`).join(", ")}]`,
+    `   - description: "${descText}"`,
+    `   - portMap: (from step 2, or omit for auto-assignment)`,
+    `   - seeds: [] (add startup commands if the operator supplied them)`,
+    `   - env: {} (add env vars if the operator supplied them)`,
+    `4. Confirm: call olam_runbook_show with name="${runbookName}" and display the stored runbook so the operator can verify it.`,
+    "",
+    "If olam_runbook_add fails with a validation error, surface the error verbatim \u2014 do not retry with a guessed payload."
+  ].join("\n");
+  return {
+    description: `Scaffold a new runbook named "${runbookName}" for repos: ${repoList}.`,
+    messages: [{ role: "user", content: { type: "text", text } }]
+  };
+}
+function buildTriageFailingWorldPrompt(args) {
+  const { worldId, sessionId, expectedBehaviour } = args;
+  const chunksUri = sessionId ? `olam://worlds/${worldId}/chunks?sessionId=${sessionId}` : `olam://worlds/${worldId}/chunks?sessionId=<SESSION_ID>`;
+  const chunksGuidance = sessionId ? `Read \`${chunksUri}\` for the reasoning snapshot.` : `The chunks Resource requires a sessionId \u2014 discover the active session from olam_status or olam_observe output, then read \`${chunksUri}\` with the real id to get the full reasoning snapshot.`;
+  const expectationText = expectedBehaviour ? `
+The operator described the expected behaviour as: "${expectedBehaviour}". Use this to anchor your diagnosis \u2014 look for divergence from that description.` : "";
+  const text = [
+    `Triage the failing or stuck Olam world "${worldId}" and determine whether it can be recovered.${expectationText}`,
+    "",
+    "Follow this sequence:",
+    `1. Confirm the world exists: call olam_status with worldId="${worldId}" (use olam_list if you need to discover worldIds \u2014 do not guess). Note the current status, thoughtCount, and any error field.`,
+    `2. Read the latest reasoning to understand the failure: ${chunksGuidance} Alternatively tail live with olam_observe. Look for the last meaningful reasoning step and any error or block the agent reported.`,
+    `3. Diagnose:`,
+    `   a. If the agent is blocked by a missing tool or credential, the world cannot self-recover \u2014 crystallise its work (olam_crystallize with worldId="${worldId}") and report the block to the operator.`,
+    `   b. If the agent looped or drifted from the task, form a corrective dispatch prompt that names the deviation and the expected outcome, then call olam_dispatch with worldId="${worldId}" and the corrective prompt.`,
+    `   c. If the agent appears to have completed its task but did not report success, call olam_status again and report the final thoughtCount and any completion signal.`,
+    `   d. If the world is in a terminal error state with no recoverable path, call olam_destroy with worldId="${worldId}" and report what was lost.`,
+    "",
+    "Report which branch (a/b/c/d) was taken, why, and the outcome. Do not retry with a vague re-dispatch if you cannot identify the specific failure cause \u2014 crystallise and report instead."
+  ].join("\n");
+  return {
+    description: `Triage and recover the failing Olam world "${worldId}".`,
+    messages: [{ role: "user", content: { type: "text", text } }]
+  };
+}
+function buildCreateWorldForLinearIssuePrompt(args) {
+  const { linearTicketId, runbookName, task } = args;
+  const runbookStep = runbookName ? [
+    `1. Inspect the runbook so you know what it sets up: call olam_runbook_show with name="${runbookName}". If it does not exist, list options with olam_runbook_list \u2014 do not invent a runbook name.`,
+    `2. Create the world with the Linear ticket wired in: call olam_create with linearTicketId="${linearTicketId}" and runbookName="${runbookName}". ${task ? `Set task="${task}".` : `Omit task \u2014 the ticket drives context.`} Do not guess the worldId; it is returned by olam_create.`
+  ] : [
+    `1. Create the world with the Linear ticket wired in: call olam_create with linearTicketId="${linearTicketId}". ${task ? `Set task="${task}".` : `Omit task \u2014 the ticket drives context.`} Do not guess the worldId; it is returned by olam_create.`
+  ];
+  const observeStep = runbookName ? `3. Confirm the agent picked up the ticket: call olam_observe with the worldId returned in step 2 and report the first few reasoning chunks.` : `2. Confirm the agent picked up the ticket: call olam_observe with the worldId returned in step 1 and report the first few reasoning chunks.`;
+  const text = [
+    `Create an Olam world pre-wired to Linear issue "${linearTicketId}"${runbookName ? ` using runbook "${runbookName}"` : ""}.`,
+    "",
+    "Follow this sequence:",
+    ...runbookStep,
+    observeStep,
+    "",
+    "The linearTicketId param passes the ticket's title, description, and metadata into the world's context automatically \u2014 this is the correct integration point for Linear-agent flows. Do not manually copy ticket text into a task string.",
+    "If olam_create fails with a context or auth error, stop and report the error verbatim \u2014 do not retry with a guessed worldId."
+  ].join("\n");
+  return {
+    description: `Create a world for Linear issue "${linearTicketId}"${runbookName ? ` with runbook "${runbookName}"` : ""}.`,
+    messages: [{ role: "user", content: { type: "text", text } }]
+  };
+}
+function buildReviewPrGatePrompt(args) {
+  const { gateId, worldName, by } = args;
+  const byClause = by ?? "mcp";
+  const discoveryClause = gateId ? `The gate id is "${gateId}", so you can call olam_pr_show with id="${gateId}" directly.` : worldName ? `No gate id was given. List open gates via olam_pr_list and find the gate whose world name contains "${worldName}". If multiple gates match, list them and ask the operator which to act on \u2014 do not guess.` : `No gate id or world name was given. Call olam_pr_list to see all open gates across every running world. Pick the gate the operator intends or list them and ask \u2014 do not fabricate an id.`;
+  const text = [
+    `Review a PR gate and decide whether to approve or block it.`,
+    "",
+    "Follow this sequence:",
+    `1. Discover the gate: ${discoveryClause}`,
+    `2. Inspect the gate in detail: call olam_pr_show with the resolved gate id. Read the diff-stat and commit log it returns carefully. Do NOT approve or reject until you have read this output.`,
+    `3. Form a decision based on what the diff-stat and commit log show:`,
+    `   a. If the changes look correct and complete for their stated goal, call olam_pr_approve with id=<gate-id> and by="${byClause}". Add a reason arg summarising what you verified.`,
+    `   b. If the changes have issues (missing tests, logic errors, wrong files changed, unrelated modifications), call olam_pr_reject with id=<gate-id>, by="${byClause}", and a reason arg that names the specific problem(s). The reason arg is REQUIRED by olam_pr_reject \u2014 do not omit it.`,
+    `4. Report the gate id, the world name, your decision, and a one-sentence summary of the reason.`,
+    "",
+    "Do not approve a gate you have not inspected. The diff-stat from step 2 is the minimum evidence required for a non-trivial approve.",
+    "If the gate is already in a decided state (approved or blocked), report that and stop \u2014 do not re-decide a closed gate."
+  ].join("\n");
+  return {
+    description: gateId ? `Review PR gate "${gateId}" and approve or block it.` : worldName ? `Review the open PR gate for world "${worldName}" and approve or block it.` : "Review open PR gates and decide approve or block.",
+    messages: [{ role: "user", content: { type: "text", text } }]
+  };
+}
+function buildPromoteToLanePrompt(args) {
+  const { worldId, task, laneName, existingLaneId } = args;
+  const laneLabel = laneName ?? "the experiment";
+  const createBlock = existingLaneId ? [
+    `Lane "${existingLaneId}" was supplied \u2014 skip creation and go to step 3.`
+  ] : [
+    `2. Check for a lane name collision: call olam_list_lanes with worldId="${worldId}". If a lane named "${laneLabel}" already exists, stop and ask the operator whether to reuse it or pick a different name.`,
+    `3. Create the lane: call olam_create_lane with worldId="${worldId}"` + (laneName ? ` and name="${laneName}".` : ".") + ` The returned laneId is required for the next step \u2014 capture it.`
+  ];
+  const laneIdRef = existingLaneId ? `"${existingLaneId}"` : "the laneId from step 3";
+  const dispatchStep = existingLaneId ? "2" : "4";
+  const observeStep = existingLaneId ? "3" : "5";
+  const text = [
+    `Promote work from Olam world "${worldId}" to a lane for parallel experimentation.`,
+    "",
+    "Follow this sequence:",
+    `1. Confirm the source world is running: call olam_status with worldId="${worldId}" (use olam_list if you need to discover worldIds \u2014 do not guess). If the world is not in "running" status, stop and report it \u2014 lane creation requires a live running world.`,
+    ...createBlock,
+    `${dispatchStep}. Dispatch the experiment into the LANE (not the world): call olam_dispatch_lane with worldId="${worldId}", laneId=${laneIdRef}, and prompt="${task}". IMPORTANT: use olam_dispatch_lane, not olam_dispatch \u2014 they are different tools. olam_dispatch sends work to the world itself; olam_dispatch_lane sends it to an isolated lane branch.`,
+    `${observeStep}. Confirm the lane picked up the task: call olam_observe with worldId="${worldId}" and laneId=${laneIdRef}. Report the first few reasoning chunks from the lane.`,
+    "",
+    "If any step fails, stop and report which step failed and the error. Do not proceed to a later step on a failed precondition.",
+    "When the experiment is complete, the operator can call olam_merge_lane to fold the lane's work back into the world, or olam_destroy_lane to discard it."
+  ].join("\n");
+  return {
+    description: existingLaneId ? `Dispatch task into existing lane "${existingLaneId}" of world "${worldId}".` : `Create a lane from world "${worldId}" and dispatch: ${task.slice(0, 60)}${task.length > 60 ? "\u2026" : ""}`,
+    messages: [{ role: "user", content: { type: "text", text } }]
+  };
+}
+
+// ../mcp-server/src/prompts/index.ts
+function registerAllPrompts(server) {
+  server.registerPrompt(
+    INSPECT_REASONING_PROMPT_NAME,
+    {
+      title: "Inspect a world's reasoning stream",
+      description: "Guided workflow to inspect what an Olam world is currently reasoning about: resolve the world, read its chunk substrate via the MCP Resource (scoped to a session), and tail it live with olam_observe.",
+      argsSchema: {
+        worldId: external_exports.string().describe(
+          'Slug-style world identifier, e.g. "amber-fox-42". Call olam_list first to discover live worldIds \u2014 do not guess.'
+        ),
+        sessionId: external_exports.string().optional().describe(
+          "Optional planning-session id. The chunks Resource requires it at read time; if omitted the prompt instructs the agent to discover it first."
+        )
+      }
+    },
+    (args) => {
+      const result = buildInspectReasoningPrompt({
+        worldId: args.worldId,
+        sessionId: args.sessionId
+      });
+      return {
+        description: result.description,
+        messages: result.messages
+      };
+    }
+  );
+  server.registerPrompt(
+    DISPATCH_FROM_RUNBOOK_PROMPT_NAME,
+    {
+      title: "Dispatch a task from a runbook",
+      description: "Guided workflow to prepare an Olam world with a named runbook and then dispatch a task into it: inspect the runbook, apply it to the world, dispatch the task, and confirm pickup via olam_observe.",
+      argsSchema: {
+        worldId: external_exports.string().describe(
+          'Slug-style world identifier, e.g. "amber-fox-42". Call olam_list first to discover live worldIds \u2014 do not guess.'
+        ),
+        runbookName: external_exports.string().describe(
+          "Name of a registered runbook to apply before dispatch. Use olam_runbook_list to discover available runbooks."
+        ),
+        task: external_exports.string().describe(
+          "The task prompt to dispatch into the world once the runbook is applied."
+        )
+      }
+    },
+    (args) => {
+      const result = buildDispatchFromRunbookPrompt({
+        worldId: args.worldId,
+        runbookName: args.runbookName,
+        task: args.task
+      });
+      return {
+        description: result.description,
+        messages: result.messages
+      };
+    }
+  );
+  server.registerPrompt(
+    DESTROY_WORLD_PROMPT_NAME,
+    {
+      title: "Destroy a world by name",
+      description: "Guided workflow to safely destroy an Olam world: discover the worldId from the human-readable name via olam_list, confirm it is idle via olam_status, then call olam_destroy. Guards against destroying the wrong world when multiple worlds have similar names.",
+      argsSchema: {
+        worldName: external_exports.string().describe(
+          'Human-readable world name or partial name to search for, e.g. "feature/auth-refactor". The prompt discovers the worldId for you via olam_list \u2014 do not guess the slug id.'
+        )
+      }
+    },
+    (args) => {
+      const result = buildDestroyWorldPrompt({ worldName: args.worldName });
+      return { description: result.description, messages: result.messages };
+    }
+  );
+  server.registerPrompt(
+    ROTATE_AUTH_PROMPT_NAME,
+    {
+      title: "Rotate a Claude credential",
+      description: "Guided workflow to rotate or add a Claude credential: check auth container status, start it if needed, initiate PKCE login, surface the browser URL to the operator, then complete the exchange. Encodes the state-token handoff between olam_auth_login and olam_auth_complete so the agent does not call complete with a missing or stale token.",
+      argsSchema: {
+        accountLabel: external_exports.string().optional().describe(
+          'Label for the credential, e.g. "work" or "personal". If omitted the prompt uses a placeholder and asks the operator to supply one.'
+        ),
+        provider: external_exports.string().optional().describe(
+          'OAuth provider \u2014 defaults to "claude". Pass a different value only when the operator has a non-standard provider configured.'
+        )
+      }
+    },
+    (args) => {
+      const result = buildRotateAuthPrompt({
+        accountLabel: args.accountLabel,
+        provider: args.provider
+      });
+      return { description: result.description, messages: result.messages };
+    }
+  );
+  server.registerPrompt(
+    SCAFFOLD_RUNBOOK_PROMPT_NAME,
+    {
+      title: "Scaffold a new runbook",
+      description: "Guided workflow to scaffold a new Olam runbook: check for name collisions via olam_runbook_list, optionally derive a portMap from a live world via olam_status, then call olam_runbook_add with a well- formed payload and confirm the result via olam_runbook_show. Prevents the common mistake of calling add with a malformed portMap or a duplicate name.",
+      argsSchema: {
+        runbookName: external_exports.string().describe(
+          'Name for the new runbook, e.g. "node-devbox". Must be unique \u2014 this prompt checks for collisions first.'
+        ),
+        repos: external_exports.string().describe(
+          'Comma-separated repo slugs to include, e.g. "my-org/my-api,my-org/my-frontend". At least one required. MCP prompt arguments are string-valued; split on commas.'
+        ),
+        description: external_exports.string().optional().describe(
+          'Human-readable description stored with the runbook. Defaults to "Runbook for <repos>" when omitted.'
+        ),
+        templateWorldId: external_exports.string().optional().describe(
+          "Optional worldId of a live world whose portOffset to use as a portMap baseline. When supplied the prompt calls olam_status on that world before building the add payload."
+        )
+      }
+    },
+    (args) => {
+      const repos = args.repos.split(",").map((r) => r.trim()).filter(Boolean);
+      const result = buildScaffoldRunbookPrompt({
+        runbookName: args.runbookName,
+        repos,
+        description: args.description,
+        templateWorldId: args.templateWorldId
+      });
+      return { description: result.description, messages: result.messages };
+    }
+  );
+  server.registerPrompt(
+    TRIAGE_FAILING_WORLD_PROMPT_NAME,
+    {
+      title: "Triage a failing or stuck world",
+      description: "Guided workflow to diagnose and recover a world that is stuck or has failed mid-task: confirm the world exists, read its latest reasoning via the chunks Resource or olam_observe to identify the failure cause, then choose the right recovery action \u2014 corrective re-dispatch, crystallise, or destroy. Prevents vague re-dispatches that loop.",
+      argsSchema: {
+        worldId: external_exports.string().describe(
+          'Slug-style world identifier, e.g. "amber-fox-42". Call olam_list first to discover live worldIds \u2014 do not guess.'
+        ),
+        sessionId: external_exports.string().optional().describe(
+          "Optional planning-session id. Supplying it lets the prompt build a ready-to-read chunks URI directly, avoiding a missing_session_id round-trip."
+        ),
+        expectedBehaviour: external_exports.string().optional().describe(
+          "Optional description of what the world was supposed to do. Anchors the diagnosis by naming the deviation from expected behaviour."
+        )
+      }
+    },
+    (args) => {
+      const result = buildTriageFailingWorldPrompt({
+        worldId: args.worldId,
+        sessionId: args.sessionId,
+        expectedBehaviour: args.expectedBehaviour
+      });
+      return { description: result.description, messages: result.messages };
+    }
+  );
+  server.registerPrompt(
+    CREATE_WORLD_FOR_LINEAR_ISSUE_PROMPT_NAME,
+    {
+      title: "Create a world for a Linear issue",
+      description: "Guided workflow to create an Olam world pre-wired to a Linear ticket: optionally inspect a named runbook, call olam_create with linearTicketId so the world inherits the ticket's title and description automatically, then confirm pickup via olam_observe. The correct integration point for Linear-agent flows \u2014 prevents manually threading ticket text into the task string.",
+      argsSchema: {
+        linearTicketId: external_exports.string().describe(
+          `Linear issue identifier, e.g. "ENG-1234". Passed directly to olam_create as linearTicketId so the world's context includes the ticket's title and description.`
+        ),
+        runbookName: external_exports.string().optional().describe(
+          "Optional name of a registered runbook to apply when creating the world. Use olam_runbook_list to discover available runbooks."
+        ),
+        task: external_exports.string().optional().describe(
+          "Optional initial task prompt. When omitted the ticket's own description drives the world's first dispatch."
+        )
+      }
+    },
+    (args) => {
+      const result = buildCreateWorldForLinearIssuePrompt({
+        linearTicketId: args.linearTicketId,
+        runbookName: args.runbookName,
+        task: args.task
+      });
+      return { description: result.description, messages: result.messages };
+    }
+  );
+  server.registerPrompt(
+    REVIEW_PR_GATE_PROMPT_NAME,
+    {
+      title: "Review a PR gate and decide approve or block",
+      description: "Guided workflow to review a PR gate opened by a running world: discover the gate via olam_pr_list (or accept a known gateId), inspect the diff-stat and commit log via olam_pr_show BEFORE deciding, then call olam_pr_approve or olam_pr_reject with a reason. Encodes the inspect-first safety contract and surfaces that olam_pr_reject requires a reason arg.",
+      argsSchema: {
+        gateId: external_exports.string().optional().describe(
+          'Short or full PR gate id, e.g. "a1b2c3d4". When supplied the prompt skips the discovery step and calls olam_pr_show directly. Omit to have the prompt discover open gates via olam_pr_list.'
+        ),
+        worldName: external_exports.string().optional().describe(
+          'Human-readable world name or partial name to filter gates by, e.g. "feature/auth-refactor". Used when gateId is unknown but you know which world opened the gate.'
+        ),
+        by: external_exports.string().optional().describe(
+          'Deciding identity recorded in the gate audit trail, e.g. "codex" or "human:ernest". Defaults to "mcp". Use a meaningful label so the audit trail shows who (or what automation) decided.'
+        )
+      }
+    },
+    (args) => {
+      const result = buildReviewPrGatePrompt({
+        gateId: args.gateId,
+        worldName: args.worldName,
+        by: args.by
+      });
+      return { description: result.description, messages: result.messages };
+    }
+  );
+  server.registerPrompt(
+    PROMOTE_TO_LANE_PROMPT_NAME,
+    {
+      title: "Promote world work to a lane for parallel experimentation",
+      description: "Guided workflow to create a lane off a running world and dispatch an experiment task into it: confirm the world is running via olam_status, check for lane name collisions via olam_list_lanes, create the lane via olam_create_lane, dispatch into the lane via olam_dispatch_lane (NOT olam_dispatch \u2014 different tool), and confirm pickup via olam_observe. Prevents the common mistake of dispatching to the world instead of the lane.",
+      argsSchema: {
+        worldId: external_exports.string().describe(
+          'Slug-style world identifier, e.g. "amber-fox-42". Call olam_list first to discover live worldIds \u2014 do not guess.'
+        ),
+        task: external_exports.string().describe(
+          "The experiment task prompt to dispatch into the lane. This is the same prompt you would pass to olam_dispatch_lane."
+        ),
+        laneName: external_exports.string().optional().describe(
+          'Optional name for the new lane, e.g. "try-new-cache-strategy". When omitted the prompt lets olam assign a name automatically.'
+        ),
+        existingLaneId: external_exports.string().optional().describe(
+          "Optional id of an already-created lane to dispatch into. When supplied the prompt skips the creation steps and goes straight to olam_dispatch_lane."
+        )
+      }
+    },
+    (args) => {
+      const result = buildPromoteToLanePrompt({
+        worldId: args.worldId,
+        task: args.task,
+        laneName: args.laneName,
+        existingLaneId: args.existingLaneId
+      });
+      return { description: result.description, messages: result.messages };
+    }
+  );
+  logger.info("Olam MCP prompts registered", {
+    prompts: [
+      INSPECT_REASONING_PROMPT_NAME,
+      DISPATCH_FROM_RUNBOOK_PROMPT_NAME,
+      DESTROY_WORLD_PROMPT_NAME,
+      ROTATE_AUTH_PROMPT_NAME,
+      SCAFFOLD_RUNBOOK_PROMPT_NAME,
+      TRIAGE_FAILING_WORLD_PROMPT_NAME,
+      CREATE_WORLD_FOR_LINEAR_ISSUE_PROMPT_NAME,
+      REVIEW_PR_GATE_PROMPT_NAME,
+      PROMOTE_TO_LANE_PROMPT_NAME
+    ]
   });
 }
 
 // ../mcp-server/src/server.ts
-var SERVER_NAME = "olam";
-var SERVER_VERSION = "0.1.0";
-var SERVER_INSTRUCTIONS = [
-  "Olam manages isolated development worlds. Use olam_list_worlds to see available worlds.",
-  "Use olam_create_world to provision a new world. Use olam_dispatch to send tasks.",
-  "Use olam_observe to watch a world's reasoning. Use olam_crystallize to save thoughts.",
-  "Always olam_destroy_world when done to clean up resources."
-].join("\n");
 function createServer4(ctx, initError) {
   const server = new McpServer(
     { name: SERVER_NAME, version: SERVER_VERSION },
@@ -38278,6 +39377,7 @@ function createServer4(ctx, initError) {
   );
   registerAllTools(server, ctx, initError);
   registerAllResources(server);
+  registerAllPrompts(server);
   logger.info("Olam MCP server created", {
     name: SERVER_NAME,
     version: SERVER_VERSION,
@@ -42547,23 +43647,53 @@ function deriveWorldDbName(seed, worldId) {
 var CostTracker = class {
   budgetConfig;
   records = [];
+  /** Per-world running total (USD). Updated on every record(). */
+  perWorldCost = /* @__PURE__ */ new Map();
+  /** Running total for the current calendar day (UTC, USD). */
+  dailyAccumulator = 0;
+  /** The YYYY-MM-DD string for the day dailyAccumulator covers. */
+  dailyDate = todayIsoPrefix();
   constructor(budgetConfig) {
     this.budgetConfig = budgetConfig;
   }
   // ── Mutations ────────────────────────────────────────────────────────────
   record(entry) {
     this.records.push(entry);
+    const prev = this.perWorldCost.get(entry.worldId) ?? 0;
+    this.perWorldCost.set(entry.worldId, prev + entry.costUsd);
+    const entryDay = entry.timestamp.slice(0, 10);
+    const today = todayIsoPrefix();
+    if (today !== this.dailyDate) {
+      this.dailyDate = today;
+      this.dailyAccumulator = 0;
+      for (const r of this.records) {
+        if (r.timestamp.startsWith(today)) {
+          this.dailyAccumulator += r.costUsd;
+        }
+      }
+    } else if (entryDay === today) {
+      this.dailyAccumulator += entry.costUsd;
+    }
   }
   // ── Queries ──────────────────────────────────────────────────────────────
   getWorldCost(worldId) {
-    return this.records.filter((r) => r.worldId === worldId).reduce((sum, r) => sum + r.costUsd, 0);
+    return this.perWorldCost.get(worldId) ?? 0;
   }
   getWorldRecords(worldId) {
     return this.records.filter((r) => r.worldId === worldId);
   }
   getDailyCost() {
-    const todayPrefix = todayIsoPrefix();
-    return this.records.filter((r) => r.timestamp.startsWith(todayPrefix)).reduce((sum, r) => sum + r.costUsd, 0);
+    const today = todayIsoPrefix();
+    if (today !== this.dailyDate) {
+      this.dailyDate = today;
+      this.dailyAccumulator = 0;
+      for (const r of this.records) {
+        if (r.timestamp.startsWith(today)) {
+          this.dailyAccumulator += r.costUsd;
+        }
+      }
+    }
+    return this.dailyAccumulator;
   }
   // ── Budget checks ────────────────────────────────────────────────────────
   checkBudget(worldId) {