poe-code 3.0.73 → 3.0.75

package/dist/index.js

@@ -6471,13 +6471,13 @@ var init_acp_transport = __esm({
           env,
           requestTimeoutMs,
           firstRequestId,
-          spawn: spawn6 = spawnChildProcess4
+          spawn: spawn7 = spawnChildProcess4
         } = options;
         this.command = command;
         this.closed = new Promise((resolve) => {
           this.resolveClosed = resolve;
         });
-        this.child = spawn6(command, [...args], {
+        this.child = spawn7(command, [...args], {
           cwd,
           env,
           stdio: ["pipe", "pipe", "pipe"]
@@ -7466,6 +7466,7 @@ function createProvider(opts) {
     branding: opts.branding,
     disabled: opts.disabled,
     supportsStdinPrompt: opts.supportsStdinPrompt,
+    supportsMcpSpawn: opts.supportsMcpSpawn,
     configurePrompts: opts.configurePrompts,
     postConfigureMessages: opts.postConfigureMessages,
     isolatedEnv: opts.isolatedEnv,
@@ -7695,17 +7696,1433 @@ var init_chat = __esm({
   }
 });
 
+// packages/tiny-mcp-client/src/internal.ts
+import { spawn as spawn4 } from "node:child_process";
+import { PassThrough } from "node:stream";
+function defaultStdioSpawn(command, args, options) {
+  return spawn4(command, args, options);
+}
+function defaultHttpTransportFetch(input, init) {
+  return fetch(input, init);
+}
+function serializeJsonRpcMessage2(message) {
+  return `${JSON.stringify(message)}
+`;
+}
+function chunkToString3(chunk) {
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  if (chunk instanceof Uint8Array) {
+    return Buffer.from(chunk).toString("utf8");
+  }
+  return String(chunk);
+}
+function normalizeLine2(line) {
+  return line.endsWith("\r") ? line.slice(0, -1) : line;
+}
+async function* readLines3(stream) {
+  let buffer = "";
+  for await (const chunk of stream) {
+    buffer += chunkToString3(chunk);
+    while (true) {
+      const newlineIndex = buffer.indexOf("\n");
+      if (newlineIndex === -1) {
+        break;
+      }
+      const line = buffer.slice(0, newlineIndex);
+      buffer = buffer.slice(newlineIndex + 1);
+      yield normalizeLine2(line);
+    }
+  }
+  if (buffer.length > 0) {
+    yield normalizeLine2(buffer);
+  }
+}
+function isObjectRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn2(value, property) {
+  return Object.prototype.hasOwnProperty.call(value, property);
+}
+function isRequestId2(value) {
+  return typeof value === "string" || typeof value === "number";
+}
+function isLogLevel(value) {
+  return value === "debug" || value === "info" || value === "notice" || value === "warning" || value === "error" || value === "critical" || value === "alert" || value === "emergency";
+}
+function toRequestId2(value) {
+  return isRequestId2(value) ? value : null;
+}
+function parseError2() {
+  return new McpError(ERROR_PARSE, "Parse error");
+}
+function invalidRequest2() {
+  return new McpError(ERROR_INVALID_REQUEST, "Invalid Request");
+}
+function isJsonRpcErrorObject2(value) {
+  if (!isObjectRecord3(value)) {
+    return false;
+  }
+  if (typeof value.code !== "number" || typeof value.message !== "string") {
+    return false;
+  }
+  return value.data === void 0 || hasOwn2(value, "data");
+}
+function parseJsonRpcPayload(parsed) {
+  if (!isObjectRecord3(parsed)) {
+    return {
+      type: "invalid",
+      id: null,
+      error: invalidRequest2()
+    };
+  }
+  const id = toRequestId2(parsed.id);
+  if (parsed.jsonrpc !== "2.0") {
+    return {
+      type: "invalid",
+      id,
+      error: invalidRequest2()
+    };
+  }
+  const hasMethod = hasOwn2(parsed, "method");
+  const hasId = hasOwn2(parsed, "id");
+  if (hasMethod) {
+    if (typeof parsed.method !== "string") {
+      return {
+        type: "invalid",
+        id,
+        error: invalidRequest2()
+      };
+    }
+    if (hasId) {
+      if (!isRequestId2(parsed.id)) {
+        return {
+          type: "invalid",
+          id: null,
+          error: invalidRequest2()
+        };
+      }
+      const request = {
+        jsonrpc: "2.0",
+        id: parsed.id,
+        method: parsed.method
+      };
+      if (hasOwn2(parsed, "params")) {
+        request.params = parsed.params;
+      }
+      return {
+        type: "request",
+        message: request
+      };
+    }
+    const notification = {
+      jsonrpc: "2.0",
+      method: parsed.method
+    };
+    if (hasOwn2(parsed, "params")) {
+      notification.params = parsed.params;
+    }
+    return {
+      type: "notification",
+      message: notification
+    };
+  }
+  if (!hasId || !isRequestId2(parsed.id)) {
+    return {
+      type: "invalid",
+      id,
+      error: invalidRequest2()
+    };
+  }
+  const hasResult = hasOwn2(parsed, "result");
+  const hasError = hasOwn2(parsed, "error");
+  if (hasResult === hasError) {
+    return {
+      type: "invalid",
+      id: parsed.id,
+      error: invalidRequest2()
+    };
+  }
+  if (hasResult) {
+    return {
+      type: "response",
+      message: {
+        jsonrpc: "2.0",
+        id: parsed.id,
+        result: parsed.result
+      }
+    };
+  }
+  if (!isJsonRpcErrorObject2(parsed.error)) {
+    return {
+      type: "invalid",
+      id: parsed.id,
+      error: invalidRequest2()
+    };
+  }
+  return {
+    type: "response",
+    message: {
+      jsonrpc: "2.0",
+      id: parsed.id,
+      error: parsed.error
+    }
+  };
+}
+var MCP_PROTOCOL_VERSION, McpClient, ERROR_PARSE, ERROR_INVALID_REQUEST, ERROR_METHOD_NOT_FOUND, ERROR_INTERNAL, StdioTransport, HttpTransport, HttpTransportGetSseNotSupportedError, McpError, SseParser, JsonRpcMessageLayer2;
+var init_internal = __esm({
+  "packages/tiny-mcp-client/src/internal.ts"() {
+    "use strict";
+    MCP_PROTOCOL_VERSION = "2025-03-26";
+    McpClient = class {
+      currentState = "disconnected";
+      currentServerCapabilities = null;
+      currentServerInfo = null;
+      currentInstructions;
+      options;
+      transport = null;
+      messageLayer = null;
+      constructor(options) {
+        this.options = options;
+      }
+      get state() {
+        return this.currentState;
+      }
+      get serverCapabilities() {
+        return this.currentServerCapabilities;
+      }
+      get serverInfo() {
+        return this.currentServerInfo;
+      }
+      get instructions() {
+        return this.currentInstructions;
+      }
+      getMessageLayerOrThrow() {
+        if (this.currentState === "disconnected") {
+          throw new Error("MCP client is disconnected");
+        }
+        if (this.currentState === "closed") {
+          throw new Error("MCP client is closed");
+        }
+        if (this.messageLayer === null) {
+          throw new Error("MCP client is disconnected");
+        }
+        return this.messageLayer;
+      }
+      async connect(transport) {
+        if (this.currentState !== "disconnected" && this.currentState !== "closed") {
+          throw new Error("MCP client is already connected");
+        }
+        const transportClosedReason = transport.closed.then((closedEvent) => closedEvent.reason).catch(
+          (error2) => error2 instanceof Error ? error2 : new Error(String(error2))
+        );
+        const messageLayer = new JsonRpcMessageLayer2(
+          transport.readable,
+          transport.writable,
+          3e4,
+          transportClosedReason
+        );
+        const {
+          onSamplingRequest,
+          onRootsList,
+          onToolsChanged,
+          onResourcesChanged,
+          onResourceUpdated,
+          onPromptsChanged,
+          onLog,
+          onProgress
+        } = this.options;
+        messageLayer.onRequest("ping", () => ({}));
+        if (onSamplingRequest !== void 0) {
+          messageLayer.onRequest(
+            "sampling/createMessage",
+            (params) => onSamplingRequest(params)
+          );
+        }
+        if (onRootsList !== void 0) {
+          messageLayer.onRequest("roots/list", async () => ({
+            roots: await onRootsList()
+          }));
+        }
+        messageLayer.onNotification("notifications/tools/list_changed", async () => {
+          if (onToolsChanged === void 0) {
+            return;
+          }
+          await onToolsChanged();
+        });
+        messageLayer.onNotification("notifications/resources/list_changed", async () => {
+          if (onResourcesChanged === void 0) {
+            return;
+          }
+          await onResourcesChanged();
+        });
+        messageLayer.onNotification("notifications/resources/updated", async (params) => {
+          if (onResourceUpdated === void 0) {
+            return;
+          }
+          if (typeof params !== "object" || params === null || Array.isArray(params)) {
+            return;
+          }
+          const { uri } = params;
+          if (typeof uri !== "string") {
+            return;
+          }
+          await onResourceUpdated(uri);
+        });
+        messageLayer.onNotification("notifications/prompts/list_changed", async () => {
+          if (onPromptsChanged === void 0) {
+            return;
+          }
+          await onPromptsChanged();
+        });
+        messageLayer.onNotification("notifications/message", async (params) => {
+          if (onLog === void 0 || !isObjectRecord3(params) || !isLogLevel(params.level)) {
+            return;
+          }
+          if (!hasOwn2(params, "data")) {
+            return;
+          }
+          const message = {
+            level: params.level,
+            data: params.data
+          };
+          if (params.logger !== void 0) {
+            if (typeof params.logger !== "string") {
+              return;
+            }
+            message.logger = params.logger;
+          }
+          await onLog(message);
+        });
+        messageLayer.onNotification("notifications/progress", async (params) => {
+          if (onProgress === void 0 || !isObjectRecord3(params)) {
+            return;
+          }
+          const { progressToken, progress } = params;
+          if (!isRequestId2(progressToken) || typeof progress !== "number") {
+            return;
+          }
+          const progressParams = {
+            progressToken,
+            progress
+          };
+          if (params.total !== void 0) {
+            if (typeof params.total !== "number") {
+              return;
+            }
+            progressParams.total = params.total;
+          }
+          if (params.message !== void 0) {
+            if (typeof params.message !== "string") {
+              return;
+            }
+            progressParams.message = params.message;
+          }
+          await onProgress(progressParams);
+        });
+        messageLayer.onNotification("notifications/cancelled", () => void 0);
+        this.transport = transport;
+        this.messageLayer = messageLayer;
+        this.currentState = "initializing";
+        transport.closed.then((closedEvent) => {
+          if (this.transport !== transport) {
+            return;
+          }
+          this.messageLayer?.dispose(closedEvent.reason);
+          this.messageLayer = null;
+          this.transport = null;
+          this.currentState = "closed";
+        }).catch((error2) => {
+          if (this.transport !== transport) {
+            return;
+          }
+          const reason = error2 instanceof Error ? error2 : new Error(String(error2));
+          this.messageLayer?.dispose(reason);
+          this.messageLayer = null;
+          this.transport = null;
+          this.currentState = "closed";
+        });
+        const capabilities = {
+          ...this.options.capabilities ?? {}
+        };
+        if (onSamplingRequest !== void 0 && capabilities.sampling === void 0) {
+          capabilities.sampling = {};
+        }
+        if (onRootsList !== void 0) {
+          capabilities.roots = {
+            ...capabilities.roots ?? {}
+          };
+        }
+        const initializeResult = await messageLayer.sendRequest("initialize", {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          clientInfo: this.options.clientInfo,
+          capabilities
+        });
+        if (initializeResult.protocolVersion !== MCP_PROTOCOL_VERSION) {
+          throw new McpError(
+            ERROR_INVALID_REQUEST,
+            `Unsupported protocol version: ${initializeResult.protocolVersion}`
+          );
+        }
+        this.currentServerCapabilities = initializeResult.capabilities;
+        this.currentServerInfo = initializeResult.serverInfo;
+        this.currentInstructions = initializeResult.instructions;
+        messageLayer.sendNotification("notifications/initialized");
+        this.currentState = "ready";
+        return initializeResult;
+      }
+      getServerCapabilitiesOrThrow() {
+        if (this.currentServerCapabilities === null) {
+          throw new Error("MCP client has not completed initialization");
+        }
+        return this.currentServerCapabilities;
+      }
+      async listTools(params = {}) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.tools === void 0) {
+          throw new Error("Server does not support tools");
+        }
+        const requestParams = params.cursor === void 0 ? void 0 : { cursor: params.cursor };
+        return await messageLayer.sendRequest("tools/list", requestParams);
+      }
+      async callTool(params, options = {}) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.tools === void 0) {
+          throw new Error("Server does not support tools");
+        }
+        const requestParams = options.progressToken === void 0 ? params : {
+          ...params,
+          _meta: {
+            progressToken: options.progressToken
+          }
+        };
+        let requestId;
+        const requestPromise = messageLayer.sendRequest("tools/call", requestParams, {
+          onRequestId: (nextRequestId) => {
+            requestId = nextRequestId;
+          }
+        });
+        if (options.signal === void 0) {
+          return await requestPromise;
+        }
+        const signal = options.signal;
+        let abortListener;
+        const abortPromise = new Promise((_, reject) => {
+          const rejectWithAbortReason = () => {
+            if (requestId !== void 0) {
+              messageLayer.sendNotification("notifications/cancelled", { requestId });
+            }
+            reject(signal.reason);
+          };
+          abortListener = rejectWithAbortReason;
+          signal.addEventListener("abort", abortListener, { once: true });
+          if (signal.aborted) {
+            signal.removeEventListener("abort", abortListener);
+            rejectWithAbortReason();
+          }
+        });
+        try {
+          return await Promise.race([requestPromise, abortPromise]);
+        } finally {
+          if (abortListener !== void 0) {
+            signal.removeEventListener("abort", abortListener);
+          }
+        }
+      }
+      async listResources(params = {}) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.resources === void 0) {
+          throw new Error("Server does not support resources");
+        }
+        const requestParams = params.cursor === void 0 ? void 0 : { cursor: params.cursor };
+        return await messageLayer.sendRequest("resources/list", requestParams);
+      }
+      async listResourceTemplates(params = {}) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.resources === void 0) {
+          throw new Error("Server does not support resources");
+        }
+        const requestParams = params.cursor === void 0 ? void 0 : { cursor: params.cursor };
+        return await messageLayer.sendRequest("resources/templates/list", requestParams);
+      }
+      async readResource(params) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.resources === void 0) {
+          throw new Error("Server does not support resources");
+        }
+        return await messageLayer.sendRequest("resources/read", params);
+      }
+      async subscribe(uri) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.resources?.subscribe !== true) {
+          throw new Error("Server does not support resource subscriptions");
+        }
+        await messageLayer.sendRequest("resources/subscribe", { uri });
+      }
+      async unsubscribe(uri) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.resources?.subscribe !== true) {
+          throw new Error("Server does not support resource subscriptions");
+        }
+        await messageLayer.sendRequest("resources/unsubscribe", { uri });
+      }
+      async listPrompts(params = {}) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.prompts === void 0) {
+          throw new Error("Server does not support prompts");
+        }
+        const requestParams = params.cursor === void 0 ? void 0 : { cursor: params.cursor };
+        return await messageLayer.sendRequest("prompts/list", requestParams);
+      }
+      async getPrompt(params) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.prompts === void 0) {
+          throw new Error("Server does not support prompts");
+        }
+        return await messageLayer.sendRequest("prompts/get", params);
+      }
+      async complete(params) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.completions === void 0) {
+          throw new Error("Server does not support completions");
+        }
+        return await messageLayer.sendRequest("completion/complete", params);
+      }
+      async setLogLevel(level) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const serverCapabilities = this.getServerCapabilitiesOrThrow();
+        if (serverCapabilities.logging === void 0) {
+          throw new Error("Server does not support logging");
+        }
+        await messageLayer.sendRequest("logging/setLevel", { level });
+      }
+      async cancel(requestId, reason) {
+        const messageLayer = this.getMessageLayerOrThrow();
+        const params = { requestId };
+        if (reason !== void 0) {
+          params.reason = reason;
+        }
+        messageLayer.sendNotification("notifications/cancelled", params);
+      }
+      async sendRootsChanged() {
+        const messageLayer = this.getMessageLayerOrThrow();
+        messageLayer.sendNotification("notifications/roots/list_changed");
+      }
+      async ping() {
+        const messageLayer = this.getMessageLayerOrThrow();
+        await messageLayer.sendRequest("ping");
+      }
+      async close() {
+        if (this.currentState === "closed") {
+          return;
+        }
+        const closeError = new Error("MCP client closed");
+        this.messageLayer?.dispose(closeError);
+        this.transport?.dispose(closeError);
+        this.messageLayer = null;
+        this.transport = null;
+        this.currentState = "closed";
+      }
+    };
+    ERROR_PARSE = -32700;
+    ERROR_INVALID_REQUEST = -32600;
+    ERROR_METHOD_NOT_FOUND = -32601;
+    ERROR_INTERNAL = -32603;
+    StdioTransport = class _StdioTransport {
+      readable;
+      writable;
+      closed;
+      child;
+      disposed = false;
+      stderrOutput = "";
+      static STDERR_MAX_LENGTH = 65536;
+      constructor({
+        command,
+        args = [],
+        cwd,
+        env,
+        spawn: spawnProcess = defaultStdioSpawn
+      }) {
+        this.child = spawnProcess(command, args, {
+          cwd,
+          env,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+        const child = this.child;
+        this.readable = child.stdout;
+        this.writable = child.stdin;
+        child.stderr.on("data", (chunk) => {
+          this.stderrOutput += chunkToString3(chunk);
+          if (this.stderrOutput.length > _StdioTransport.STDERR_MAX_LENGTH) {
+            this.stderrOutput = this.stderrOutput.slice(-_StdioTransport.STDERR_MAX_LENGTH);
+          }
+        });
+        this.closed = new Promise((resolve) => {
+          let settled = false;
+          const resolveClosed = (event) => {
+            if (settled) {
+              return;
+            }
+            settled = true;
+            resolve(event);
+          };
+          child.once("exit", (code, signal) => {
+            const closedEvent = {
+              reason: new Error("Stdio transport process exited")
+            };
+            if (code !== null) {
+              closedEvent.code = code;
+            }
+            if (signal !== null) {
+              closedEvent.signal = signal;
+            }
+            resolveClosed(closedEvent);
+          });
+          child.once("error", (error2) => {
+            const closedEvent = {
+              reason: error2 instanceof Error ? error2 : new Error(String(error2))
+            };
+            if (child.exitCode !== null) {
+              closedEvent.code = child.exitCode;
+            }
+            if (child.signalCode !== null) {
+              closedEvent.signal = child.signalCode;
+            }
+            resolveClosed(closedEvent);
+          });
+        });
+      }
+      getStderrOutput() {
+        return this.stderrOutput;
+      }
+      dispose(reason = new Error("Stdio transport disposed")) {
+        void reason;
+        if (this.disposed) {
+          return;
+        }
+        this.disposed = true;
+        if (!this.child.stdin.destroyed && !this.child.stdin.writableEnded) {
+          this.child.stdin.end();
+        }
+        if (this.child.exitCode === null && this.child.signalCode === null && !this.child.killed) {
+          this.child.kill("SIGTERM");
+        }
+      }
+    };
+    HttpTransport = class {
+      readable;
+      writable;
+      closed;
+      url;
+      headers;
+      fetchImpl;
+      readStream = new PassThrough();
+      writeStream = new PassThrough();
+      resolveClosed;
+      sessionId;
+      lastEventId;
+      getSseStreamStarted = false;
+      disposed = false;
+      inFlightFetchAbortControllers = /* @__PURE__ */ new Set();
+      openSseReaders = /* @__PURE__ */ new Set();
+      constructor({
+        url: url2,
+        headers = {},
+        fetch: fetchImpl = defaultHttpTransportFetch
+      }) {
+        this.url = url2;
+        this.headers = headers;
+        this.fetchImpl = fetchImpl;
+        this.readable = this.readStream;
+        this.writable = this.writeStream;
+        this.closed = new Promise((resolve) => {
+          this.resolveClosed = resolve;
+        });
+        this.readStream.once("error", (error2) => {
+          this.dispose(error2 instanceof Error ? error2 : new Error(String(error2)));
+        });
+        this.writeStream.once("error", (error2) => {
+          this.dispose(error2 instanceof Error ? error2 : new Error(String(error2)));
+        });
+        this.consumeWrittenLines().catch((error2) => {
+          this.dispose(error2 instanceof Error ? error2 : new Error(String(error2)));
+        });
+      }
+      dispose(reason = new Error("HTTP transport disposed")) {
+        if (this.disposed) {
+          return;
+        }
+        this.disposed = true;
+        this.abortInFlightFetches();
+        this.cancelOpenSseReaders();
+        this.terminateSession();
+        if (!this.writeStream.destroyed && !this.writeStream.writableEnded) {
+          this.writeStream.end();
+        }
+        if (!this.readStream.destroyed && !this.readStream.writableEnded) {
+          this.readStream.end();
+        }
+        const resolveClosed = this.resolveClosed;
+        this.resolveClosed = void 0;
+        resolveClosed?.({ reason });
+      }
+      abortInFlightFetches() {
+        for (const abortController of this.inFlightFetchAbortControllers) {
+          abortController.abort();
+        }
+        this.inFlightFetchAbortControllers.clear();
+      }
+      cancelOpenSseReaders() {
+        for (const reader of this.openSseReaders) {
+          void reader.cancel().catch(() => void 0);
+        }
+        this.openSseReaders.clear();
+      }
+      async fetchWithAbort(input, init) {
+        const abortController = new AbortController();
+        this.inFlightFetchAbortControllers.add(abortController);
+        try {
+          return await this.fetchImpl(input, {
+            ...init,
+            signal: abortController.signal
+          });
+        } finally {
+          this.inFlightFetchAbortControllers.delete(abortController);
+        }
+      }
+      async consumeWrittenLines() {
+        for await (const line of readLines3(this.writeStream)) {
+          if (this.disposed || line.length === 0) {
+            continue;
+          }
+          const hasSessionId = this.sessionId !== void 0;
+          const response = await this.fetchWithAbort(this.url, {
+            method: "POST",
+            headers: this.createPostHeaders(),
+            body: line
+          });
+          if (hasSessionId && response.status === 404) {
+            this.sessionId = void 0;
+            this.dispose(new Error("HTTP transport session expired (404 response)"));
+            return;
+          }
+          await this.throwForPostHttpError(response);
+          this.captureSessionId(response);
+          this.maybeOpenGetSseStream();
+          await this.forwardResponseMessages(response);
+        }
+      }
+      createPostHeaders() {
+        const headers = new Headers(this.headers);
+        headers.set("Accept", "application/json, text/event-stream");
+        headers.set("Content-Type", "application/json");
+        if (this.sessionId !== void 0) {
+          headers.set("Mcp-Session-Id", this.sessionId);
+        }
+        return headers;
+      }
+      createGetHeaders() {
+        const headers = new Headers(this.headers);
+        headers.set("Accept", "text/event-stream");
+        if (this.sessionId !== void 0) {
+          headers.set("Mcp-Session-Id", this.sessionId);
+        }
+        if (this.lastEventId !== void 0) {
+          headers.set("Last-Event-ID", this.lastEventId);
+        }
+        return headers;
+      }
+      createDeleteHeaders(sessionId) {
+        const headers = new Headers(this.headers);
+        headers.set("Mcp-Session-Id", sessionId);
+        return headers;
+      }
+      captureSessionId(response) {
+        const sessionId = response.headers.get("Mcp-Session-Id");
+        if (sessionId === null || sessionId.length === 0) {
+          return;
+        }
+        this.sessionId = sessionId;
+      }
+      maybeOpenGetSseStream() {
+        if (this.disposed || this.sessionId === void 0 || this.getSseStreamStarted) {
+          return;
+        }
+        this.getSseStreamStarted = true;
+        this.consumeGetSseStream().catch((error2) => {
+          if (error2 instanceof HttpTransportGetSseNotSupportedError || this.disposed) {
+            return;
+          }
+          this.dispose(error2 instanceof Error ? error2 : new Error(String(error2)));
+        });
+      }
+      terminateSession() {
+        if (this.sessionId === void 0) {
+          return;
+        }
+        const sessionId = this.sessionId;
+        this.sessionId = void 0;
+        this.sendSessionTerminationRequest(sessionId).catch(() => void 0);
+      }
+      async sendSessionTerminationRequest(sessionId) {
+        const response = await this.fetchImpl(this.url, {
+          method: "DELETE",
+          headers: this.createDeleteHeaders(sessionId)
+        });
+        if (response.status === 405) {
+          return;
+        }
+      }
+      async consumeGetSseStream() {
+        const response = await this.fetchWithAbort(this.url, {
+          method: "GET",
+          headers: this.createGetHeaders()
+        });
+        if (response.status === 405) {
+          throw new HttpTransportGetSseNotSupportedError();
+        }
+        const contentType = response.headers.get("Content-Type");
+        if (contentType === null) {
+          return;
+        }
+        if (contentType.toLowerCase().includes("text/event-stream")) {
+          await this.forwardSseResponseMessages(response);
+          this.getSseStreamStarted = false;
+          if (!this.disposed && this.sessionId !== void 0 && this.lastEventId !== void 0) {
+            this.maybeOpenGetSseStream();
+          }
+        }
+      }
+      async throwForPostHttpError(response) {
+        if (response.status < 400) {
+          return;
+        }
+        const responseBody = (await response.text()).trim();
+        const statusDescriptor = `${response.status} ${response.statusText}`.trim();
+        const message = responseBody.length === 0 ? `HTTP transport POST failed (${statusDescriptor})` : `HTTP transport POST failed (${statusDescriptor}): ${responseBody}`;
+        throw new Error(message);
+      }
+      async forwardResponseMessages(response) {
+        if (response.status === 202) {
+          return;
+        }
+        const contentType = response.headers.get("Content-Type");
+        if (contentType === null) {
+          return;
+        }
+        const normalizedContentType = contentType.toLowerCase();
+        if (normalizedContentType.includes("text/event-stream")) {
+          await this.forwardSseResponseMessages(response);
+          return;
+        }
+        if (normalizedContentType.includes("application/json")) {
+          await this.forwardJsonResponseMessage(response);
+        }
+      }
+      async forwardSseResponseMessages(response) {
+        if (response.body === null) {
+          return;
+        }
+        const parser = new SseParser();
+        const decoder = new TextDecoder();
+        const reader = response.body.getReader();
+        this.openSseReaders.add(reader);
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+              break;
+            }
+            if (value === void 0) {
+              continue;
+            }
+            const messages = parser.push(decoder.decode(value, { stream: true }));
+            this.writeSseMessages(messages);
+            this.lastEventId = parser.lastEventId;
+          }
+          const trailingChunk = decoder.decode();
+          if (trailingChunk.length > 0) {
+            this.writeSseMessages(parser.push(trailingChunk));
+            this.lastEventId = parser.lastEventId;
+          }
+          this.writeSseMessages(parser.flush());
+          this.lastEventId = parser.lastEventId;
+        } finally {
+          this.openSseReaders.delete(reader);
+          reader.releaseLock();
+        }
+      }
+      async forwardJsonResponseMessage(response) {
+        const payload = await response.text();
+        if (payload.length === 0) {
+          return;
+        }
+        const parsedPayload = JSON.parse(payload);
+        this.writeReadableLine(JSON.stringify(parsedPayload));
+      }
+      writeSseMessages(messages) {
+        for (const message of messages) {
+          this.writeReadableLine(message.data);
+        }
+      }
+      writeReadableLine(line) {
+        if (this.disposed || this.readStream.destroyed || this.readStream.writableEnded) {
+          return;
+        }
+        this.readStream.write(`${line}
+`);
+      }
+    };
+    HttpTransportGetSseNotSupportedError = class extends Error {
+      constructor() {
+        super("HTTP transport server does not support GET SSE streams");
+      }
+    };
+    McpError = class extends Error {
+      code;
+      constructor(code, message, data) {
+        super(message);
+        this.name = "McpError";
+        this.code = code;
+        if (data !== void 0) {
+          this.data = data;
+        }
+      }
+    };
+    SseParser = class {
+      buffer = "";
+      eventType;
+      dataLines = [];
+      eventId = "";
+      hasEventId = false;
+      _lastEventId;
+      get lastEventId() {
+        return this._lastEventId;
+      }
+      push(chunk) {
+        if (chunk.length === 0) {
+          return [];
+        }
+        this.buffer += chunk;
+        const messages = [];
+        while (true) {
+          const newlineIndex = this.buffer.indexOf("\n");
+          if (newlineIndex === -1) {
+            break;
+          }
+          const line = normalizeLine2(this.buffer.slice(0, newlineIndex));
+          this.buffer = this.buffer.slice(newlineIndex + 1);
+          this.consumeLine(line, messages);
+        }
+        return messages;
+      }
+      flush() {
+        const messages = [];
+        if (this.buffer.length > 0) {
+          this.consumeLine(normalizeLine2(this.buffer), messages);
+          this.buffer = "";
+        }
+        this.emitEvent(messages);
+        return messages;
+      }
+      consumeLine(line, messages) {
+        if (line.length === 0) {
+          this.emitEvent(messages);
+          return;
+        }
+        if (line.startsWith(":")) {
+          return;
+        }
+        const separatorIndex = line.indexOf(":");
+        const field = separatorIndex === -1 ? line : line.slice(0, separatorIndex);
+        const rawValue = separatorIndex === -1 ? "" : line.slice(separatorIndex + 1);
+        const value = rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue;
+        if (field === "event") {
+          this.eventType = value;
+          return;
+        }
+        if (field === "data") {
+          this.dataLines.push(value);
+          return;
+        }
+        if (field === "id") {
+          if (value.includes("\0")) {
+            return;
+          }
+          this.eventId = value;
+          this.hasEventId = true;
+        }
+      }
+      emitEvent(messages) {
+        const eventType = this.eventType ?? "message";
+        if (this.hasEventId) {
+          this._lastEventId = this.eventId;
+        }
+        if (this.dataLines.length === 0 || eventType !== "message") {
+          this.resetEvent();
+          return;
+        }
+        const message = {
+          data: this.dataLines.join("\n")
+        };
+        if (this.hasEventId) {
+          message.id = this.eventId;
+        }
+        messages.push(message);
+        this.resetEvent();
+      }
+      resetEvent() {
+        this.eventType = void 0;
+        this.dataLines = [];
+        this.eventId = "";
+        this.hasEventId = false;
+      }
+    };
+    JsonRpcMessageLayer2 = class {
+      requestTimeoutMs;
+      input;
+      output;
+      inputClosedReason;
+      nextRequestId = 1;
+      disposedError;
+      pendingRequests = /* @__PURE__ */ new Map();
+      activeIncomingRequests = /* @__PURE__ */ new Map();
+      requestHandlers = /* @__PURE__ */ new Map();
+      notificationHandlers = /* @__PURE__ */ new Map();
+      constructor(input, output, requestTimeoutMs = 3e4, inputClosedReason) {
+        if (!Number.isFinite(requestTimeoutMs) || requestTimeoutMs < 0) {
+          throw new Error("requestTimeoutMs must be a non-negative finite number");
+        }
+        this.input = input;
+        this.output = output;
+        this.inputClosedReason = inputClosedReason;
+        this.requestTimeoutMs = requestTimeoutMs;
+        this.consumeInput().catch(() => void 0);
+      }
+      sendNotification(method, params) {
+        if (this.disposedError !== void 0) {
+          throw this.disposedError;
+        }
+        const message = {
+          jsonrpc: "2.0",
+          method
+        };
+        if (params !== void 0) {
+          message.params = params;
+        }
+        this.output.write(serializeJsonRpcMessage2(message));
+      }
+      onRequest(method, handler) {
+        this.requestHandlers.set(method, handler);
+      }
+      onNotification(method, handler) {
+        this.notificationHandlers.set(method, handler);
+      }
+      sendRequest(method, params, options = {}) {
+        if (this.disposedError !== void 0) {
+          throw this.disposedError;
+        }
+        const id = this.nextRequestId;
+        this.nextRequestId += 1;
+        const timeoutMs = options.timeoutMs ?? this.requestTimeoutMs;
+        if (!Number.isFinite(timeoutMs) || timeoutMs < 0) {
+          throw new Error("timeoutMs must be a non-negative finite number");
+        }
+        if (options.onRequestId !== void 0) {
+          options.onRequestId(id);
+        }
+        const message = {
+          jsonrpc: "2.0",
+          id,
+          method
+        };
+        if (params !== void 0) {
+          message.params = params;
+        }
+        return new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+            this.pendingRequests.delete(id);
+            reject(new Error(`JSON-RPC request "${method}" timed out after ${timeoutMs}ms`));
+          }, timeoutMs);
+          this.pendingRequests.set(id, { resolve, reject, timeout });
+          try {
+            this.output.write(serializeJsonRpcMessage2(message));
+          } catch (error2) {
+            clearTimeout(timeout);
+            this.pendingRequests.delete(id);
+            reject(error2);
+          }
+        });
+      }
+      dispose(reason = new Error("JSON-RPC message layer disposed")) {
+        if (this.disposedError !== void 0) {
+          return;
+        }
+        this.disposedError = reason;
+        for (const pending of this.pendingRequests.values()) {
+          clearTimeout(pending.timeout);
+          pending.reject(reason);
+        }
+        this.pendingRequests.clear();
+        this.activeIncomingRequests.clear();
+      }
+      async consumeInput() {
+        try {
+          for await (const line of readLines3(this.input)) {
+            if (this.disposedError !== void 0) {
+              break;
+            }
+            if (line.length === 0) {
+              continue;
+            }
+            let parsedLine;
+            try {
+              parsedLine = JSON.parse(line);
+            } catch {
+              await this.processParsedMessage({
+                type: "invalid",
+                id: null,
+                error: parseError2()
+              });
+              continue;
+            }
+            if (Array.isArray(parsedLine)) {
+              for (const message of parsedLine) {
+                if (this.disposedError !== void 0) {
+                  break;
+                }
+                await this.processParsedMessage(parseJsonRpcPayload(message));
+              }
+              continue;
+            }
+            await this.processParsedMessage(parseJsonRpcPayload(parsedLine));
+          }
+        } catch (error2) {
+          if (this.disposedError === void 0) {
+            this.dispose(
+              error2 instanceof Error ? error2 : new Error(`JSON-RPC input stream failed: ${String(error2)}`)
+            );
+          }
+          return;
+        }
+        if (this.disposedError === void 0) {
+          const streamClosedReason = await this.resolveInputStreamClosedReason();
+          if (this.disposedError === void 0) {
+            this.dispose(streamClosedReason);
+          }
+        }
+      }
+      async resolveInputStreamClosedReason() {
+        const streamClosedError = new Error("JSON-RPC input stream closed");
+        if (this.inputClosedReason === void 0) {
+          return streamClosedError;
+        }
+        try {
+          return await Promise.race([
+            this.inputClosedReason,
+            new Promise((resolve) => {
+              setTimeout(() => {
+                resolve(streamClosedError);
+              }, 50);
+            })
+          ]);
+        } catch {
+          return streamClosedError;
+        }
+      }
+      async processParsedMessage(parsed) {
+        if (parsed.type === "request") {
+          const handler = this.requestHandlers.get(parsed.message.method);
+          if (handler === void 0) {
+            this.output.write(
+              serializeJsonRpcMessage2({
+                jsonrpc: "2.0",
+                id: parsed.message.id,
+                error: {
+                  code: ERROR_METHOD_NOT_FOUND,
+                  message: `Method not found: ${parsed.message.method}`
+                }
+              })
+            );
+            return;
+          }
+          this.handleIncomingRequest(parsed.message, handler);
+          return;
+        }
+        if (parsed.type === "notification") {
+          if (parsed.message.method === "notifications/cancelled") {
+            this.handleCancellationNotification(parsed.message.params);
+          }
+          const handler = this.notificationHandlers.get(parsed.message.method);
+          if (handler === void 0) {
+            return;
+          }
+          try {
+            await handler(parsed.message.params, {
+              method: parsed.message.method
+            });
+          } catch {
+            return;
+          }
+          return;
+        }
+        if (parsed.type === "invalid") {
+          const errorResponse = {
+            jsonrpc: "2.0",
+            id: parsed.id,
+            error: {
+              code: parsed.error.code,
+              message: parsed.error.message
+            }
+          };
+          if (parsed.error.data !== void 0) {
+            errorResponse.error.data = parsed.error.data;
+          }
+          this.output.write(`${JSON.stringify(errorResponse)}
+`);
+          return;
+        }
+        if (parsed.type !== "response") {
+          return;
+        }
+        const pending = this.pendingRequests.get(parsed.message.id);
+        if (pending === void 0) {
+          return;
+        }
+        this.pendingRequests.delete(parsed.message.id);
+        clearTimeout(pending.timeout);
+        if ("result" in parsed.message) {
+          pending.resolve(parsed.message.result);
+          return;
+        }
+        pending.reject(
+          new McpError(
+            parsed.message.error.code,
+            parsed.message.error.message,
+            parsed.message.error.data
+          )
+        );
+      }
+      handleIncomingRequest(message, handler) {
+        const activeRequest = {
+          cancelled: false
+        };
+        this.activeIncomingRequests.set(message.id, activeRequest);
+        void (async () => {
+          try {
+            const result = await handler(message.params, {
+              id: message.id,
+              method: message.method
+            });
+            if (this.disposedError !== void 0 || activeRequest.cancelled) {
+              return;
+            }
+            this.output.write(
+              serializeJsonRpcMessage2({
+                jsonrpc: "2.0",
+                id: message.id,
+                result
+              })
+            );
+          } catch (error2) {
+            if (this.disposedError !== void 0 || activeRequest.cancelled) {
+              return;
+            }
+            const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+            this.output.write(
+              serializeJsonRpcMessage2({
+                jsonrpc: "2.0",
+                id: message.id,
+                error: {
+                  code: ERROR_INTERNAL,
+                  message: errorMessage
+                }
+              })
+            );
+          } finally {
+            const inFlightRequest = this.activeIncomingRequests.get(message.id);
+            if (inFlightRequest === activeRequest) {
+              this.activeIncomingRequests.delete(message.id);
+            }
+          }
+        })();
+      }
+      handleCancellationNotification(params) {
+        if (!isObjectRecord3(params)) {
+          return;
+        }
+        const requestId = params.requestId;
+        if (!isRequestId2(requestId)) {
+          return;
+        }
+        const activeRequest = this.activeIncomingRequests.get(requestId);
+        if (activeRequest === void 0) {
+          return;
+        }
+        activeRequest.cancelled = true;
+        this.activeIncomingRequests.delete(requestId);
+      }
+    };
+  }
+});
+
+// packages/tiny-mcp-client/src/index.ts
+var init_src7 = __esm({
+  "packages/tiny-mcp-client/src/index.ts"() {
+    "use strict";
+    init_internal();
+  }
+});
+
+// packages/poe-agent/src/mcp-tool-executor.ts
+function namespaceMcpToolName(serverName, toolName) {
+  return `mcp__${serverName}__${toolName}`;
+}
+function mcpToolToOpenAiTool(serverName, mcpTool) {
+  const parameters = {
+    type: "object",
+    properties: getInputSchemaProperties(mcpTool.inputSchema)
+  };
+  const required2 = getInputSchemaRequired(mcpTool.inputSchema);
+  if (required2) {
+    parameters.required = required2;
+  }
+  return {
+    type: "function",
+    function: {
+      name: namespaceMcpToolName(serverName, mcpTool.name),
+      description: mcpTool.description ?? "",
+      parameters
+    }
+  };
+}
+function callToolResultToString(result) {
+  const content = result.content.map(contentItemToString).join("\n");
+  if (result.isError) {
+    throw new Error(content);
+  }
+  return content;
+}
+function getInputSchemaProperties(inputSchema) {
+  const properties = inputSchema.properties;
+  return isObjectRecord4(properties) ? properties : {};
+}
+function getInputSchemaRequired(inputSchema) {
+  const required2 = inputSchema.required;
+  if (!Array.isArray(required2) || required2.some((value) => typeof value !== "string")) {
+    return void 0;
+  }
+  return required2;
+}
+function contentItemToString(item) {
+  switch (item.type) {
+    case "text":
+      return item.text;
+    case "image":
+      return `[image: ${item.mimeType}]`;
+    case "audio":
+      return `[audio: ${item.mimeType}]`;
+    case "resource":
+      return resourceContentsToString(item.resource);
+  }
+}
+function resourceContentsToString(resource) {
+  if ("text" in resource) {
+    return resource.text;
+  }
+  return `[blob: ${resource.uri}]`;
+}
+function isObjectRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var McpToolExecutor;
+var init_mcp_tool_executor = __esm({
+  "packages/poe-agent/src/mcp-tool-executor.ts"() {
+    "use strict";
+    McpToolExecutor = class {
+      discoveredTools = [];
+      toolToClient = /* @__PURE__ */ new Map();
+      clients = /* @__PURE__ */ new Set();
+      disposed = false;
+      async addServer(serverName, client) {
+        this.clients.add(client);
+        let nextCursor;
+        while (true) {
+          const page = nextCursor === void 0 ? await client.listTools() : await client.listTools({ cursor: nextCursor });
+          for (const mcpTool of page.tools) {
+            const openAiTool = mcpToolToOpenAiTool(serverName, mcpTool);
+            this.discoveredTools.push(openAiTool);
+            this.toolToClient.set(openAiTool.function.name, {
+              client,
+              originalName: mcpTool.name
+            });
+          }
+          if (page.nextCursor === void 0) {
+            return;
+          }
+          nextCursor = page.nextCursor;
+        }
+      }
+      getAvailableTools() {
+        return [...this.discoveredTools];
+      }
+      async executeTool(name, args) {
+        if (this.disposed) {
+          throw new Error("MCP tool executor is disposed");
+        }
+        const registration = this.toolToClient.get(name);
+        if (!registration) {
+          throw new Error(`MCP tool not found: ${name}`);
+        }
+        const result = await registration.client.callTool({
+          name: registration.originalName,
+          arguments: args
+        });
+        return callToolResultToString(result);
+      }
+      async dispose() {
+        this.disposed = true;
+        const closeOperations = [];
+        for (const client of this.clients) {
+          if (client.close === void 0) {
+            continue;
+          }
+          closeOperations.push(client.close());
+        }
+        await Promise.allSettled(closeOperations);
+        this.clients.clear();
+      }
+    };
+  }
+});
+
+// packages/poe-agent/src/SYSTEM_PROMPT.md
+var SYSTEM_PROMPT_default;
+var init_SYSTEM_PROMPT = __esm({
+  "packages/poe-agent/src/SYSTEM_PROMPT.md"() {
+    SYSTEM_PROMPT_default = "You are a Poe agent, built by Poe \u2014 an interactive CLI tool that helps users with software engineering tasks.\n\n## Security\n\nAssist with defensive security only. Refuse malicious code, credential harvesting, or bulk crawling for secrets. Allow security analysis, detection rules, vulnerability explanations, and defensive tools.\n\nNever generate or guess URLs unless they help with programming. You may use URLs from user messages or local files.\n\n## Behavior\n\n- Be concise and direct. Minimize output tokens. Skip preamble and postamble.\n- Do what was asked \u2014 nothing more, nothing less.\n- Prefer editing existing files over creating new ones. Never create docs/READMEs unless asked.\n- Prioritize technical accuracy over validating beliefs. Disagree when necessary.\n- Read before you write.\n";
+  }
+});
+
 // packages/poe-agent/src/system-prompt.ts
-import { readFileSync } from "node:fs";
-import { readFile as readFile2 } from "node:fs/promises";
 async function loadSystemPrompt() {
-  return readFile2(systemPromptUrl, "utf8");
+  return SYSTEM_PROMPT_default;
 }
-var systemPromptUrl;
 var init_system_prompt = __esm({
   "packages/poe-agent/src/system-prompt.ts"() {
     "use strict";
-    systemPromptUrl = new URL("./SYSTEM_PROMPT.md", import.meta.url);
+    init_SYSTEM_PROMPT();
   }
 });
 
@@ -8033,7 +9450,41 @@ async function createAgentSession(options = {}) {
     cwd: options.cwd,
     allowedPaths: options.allowedPaths
   });
-  const tools = toolExecutor.getAvailableTools();
+  const builtInTools = toolExecutor.getAvailableTools();
+  const builtInToolNames = new Set(builtInTools.map((tool) => tool.function.name));
+  let tools = builtInTools;
+  let chatToolExecutor = toolExecutor;
+  let mcpToolExecutor;
+  if (options.mcpServers !== void 0) {
+    const createdMcpToolExecutor = new McpToolExecutor();
+    mcpToolExecutor = createdMcpToolExecutor;
+    try {
+      for (const [serverName, serverDefinition] of Object.entries(options.mcpServers)) {
+        const mcpClient = new McpClient({
+          clientInfo: {
+            name: "poe-agent",
+            version: "0.0.1"
+          }
+        });
+        const transport = createMcpTransport(serverDefinition);
+        await mcpClient.connect(transport);
+        await createdMcpToolExecutor.addServer(serverName, mcpClient);
+      }
+    } catch (error2) {
+      await createdMcpToolExecutor.dispose();
+      throw error2;
+    }
+    const mcpTools = createdMcpToolExecutor.getAvailableTools();
+    tools = [...builtInTools, ...mcpTools];
+    chatToolExecutor = {
+      executeTool(name, args) {
+        if (builtInToolNames.has(name)) {
+          return toolExecutor.executeTool(name, args);
+        }
+        return createdMcpToolExecutor.executeTool(name, args);
+      }
+    };
+  }
   let currentOnSessionUpdate;
   const chatService = new PoeChatService({
     apiKey,
@@ -8041,7 +9492,7 @@ async function createAgentSession(options = {}) {
     baseUrl: options.baseUrl,
     fetch: options.fetch,
     systemPrompt,
-    toolExecutor,
+    toolExecutor: chatToolExecutor,
     maxToolCallIterations: options.maxToolCallIterations,
     onToolCall: (event) => {
       if (!currentOnSessionUpdate) return;
@@ -8079,12 +9530,32 @@ async function createAgentSession(options = {}) {
       disposed = true;
       chatService.clearConversationHistory();
       const disposableToolExecutor = toolExecutor;
+      const disposePromises = [];
       if (typeof disposableToolExecutor.dispose === "function") {
-        await disposableToolExecutor.dispose();
+        disposePromises.push(Promise.resolve(disposableToolExecutor.dispose()));
+      }
+      if (mcpToolExecutor) {
+        disposePromises.push(mcpToolExecutor.dispose());
+      }
+      if (disposePromises.length > 0) {
+        await Promise.all(disposePromises);
       }
     }
   };
 }
+function createMcpTransport(server) {
+  if (server.transport === "stdio") {
+    return new StdioTransport({
+      command: server.command,
+      args: server.args,
+      env: server.env
+    });
+  }
+  return new HttpTransport({
+    url: server.url,
+    headers: server.headers
+  });
+}
 async function resolveApiKey(explicitApiKey) {
   const normalizedExplicitApiKey = normalizeNonEmptyString(explicitApiKey);
   if (normalizedExplicitApiKey) {
@@ -8148,6 +9619,8 @@ var init_agent_session = __esm({
     "use strict";
     init_src();
     init_chat();
+    init_src7();
+    init_mcp_tool_executor();
     init_system_prompt();
     init_tool_executor();
   }
@@ -8158,7 +9631,7 @@ var src_exports = {};
 __export(src_exports, {
   createAgentSession: () => createAgentSession
 });
-var init_src7 = __esm({
+var init_src8 = __esm({
   "packages/poe-agent/src/index.ts"() {
     "use strict";
     init_agent_session();
@@ -8217,6 +9690,18 @@ function createToolRenderState() {
     toolCallTitles: /* @__PURE__ */ new Map()
   };
 }
+function toAgentSessionMcpServers(servers) {
+  const mappedServers = {};
+  for (const [name, server] of Object.entries(servers)) {
+    mappedServers[name] = {
+      transport: "stdio",
+      command: server.command,
+      ...server.args && server.args.length > 0 ? { args: [...server.args] } : {},
+      ...server.env && Object.keys(server.env).length > 0 ? { env: { ...server.env } } : {}
+    };
+  }
+  return Object.keys(mappedServers).length > 0 ? mappedServers : void 0;
+}
 function toErrorMessage2(value) {
   if (value instanceof Error) {
     return value.message;
@@ -8441,6 +9926,7 @@ function createInMemoryAcpTransport(options) {
   const closedPromise = new Promise((resolve) => {
     resolveClosed = resolve;
   });
+  const sessionMcpServers = options.mcpServers ? toAgentSessionMcpServers(options.mcpServers) : void 0;
   const closeTransport = (reason) => {
     if (closed) {
       return;
@@ -8476,10 +9962,12 @@ function createInMemoryAcpTransport(options) {
       }
       if (method === "session/new") {
         const request = params;
-        const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src7(), src_exports));
+        const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src8(), src_exports));
         const session = await createAgentSession2({
           model: options.model,
-          cwd: request.cwd || options.cwd
+          cwd: request.cwd || options.cwd,
+          ...options.baseUrl ? { baseUrl: options.baseUrl } : {},
+          ...sessionMcpServers ? { mcpServers: sessionMcpServers } : {}
         });
         const sessionId = `poe-agent-session-${sessionCounter + 1}`;
         sessionCounter += 1;
@@ -8550,7 +10038,9 @@ async function runPoeAgentAcpLifecycle(options) {
   let assistantText = "";
   const transport = createInMemoryAcpTransport({
     model: options.model,
-    cwd: options.cwd
+    cwd: options.cwd,
+    baseUrl: options.baseUrl,
+    mcpServers: options.mcpServers
   });
   const client = new AcpClient({ transport });
   try {
@@ -8604,6 +10094,8 @@ function spawnPoeAgentWithAcp(options) {
     prompt: options.prompt,
     model,
     cwd,
+    baseUrl: options.baseUrl,
+    mcpServers: options.mcpServers,
     onEvent: (event) => {
       queue.push(event);
     }
@@ -8628,6 +10120,7 @@ var init_poe_agent = __esm({
       label: "Poe Agent",
       summary: "Run one-shot prompts with the built-in Poe agent runtime.",
       supportsStdinPrompt: true,
+      supportsMcpSpawn: true,
       manifest: {
         configure: []
       },
@@ -8635,7 +10128,9 @@ var init_poe_agent = __esm({
         const result = await runPoeAgentAcpLifecycle({
           prompt: options.prompt,
           model: options.model ?? DEFAULT_FRONTIER_MODEL,
-          cwd: options.cwd ?? context.env.cwd
+          cwd: options.cwd ?? context.env.cwd,
+          baseUrl: context.env.poeApiBaseUrl,
+          mcpServers: options.mcpServers
         });
         return {
           stdout: result.stdout,
@@ -8648,7 +10143,7 @@ var init_poe_agent = __esm({
 });
 
 // src/sdk/spawn.ts
-function spawn4(service, promptOrOptions, maybeOptions) {
+function spawn5(service, promptOrOptions, maybeOptions) {
   const options = typeof promptOrOptions === "string" ? { ...maybeOptions, prompt: promptOrOptions } : promptOrOptions;
   const emptyEvents = (async function* () {
   })();
@@ -8687,10 +10182,13 @@ function spawn4(service, promptOrOptions, maybeOptions) {
         };
       }
       if (service === "poe-agent") {
+        const poeBaseUrl = typeof process.env.POE_BASE_URL === "string" ? process.env.POE_BASE_URL.trim() || void 0 : void 0;
         const { events: innerEvents, done } = spawnPoeAgentWithAcp({
           prompt: options.prompt,
           cwd: options.cwd,
-          model: options.model
+          model: options.model,
+          ...poeBaseUrl ? { baseUrl: poeBaseUrl } : {},
+          ...options.mcpServers ? { mcpServers: options.mcpServers } : {}
         });
         resolveEventsOnce(innerEvents);
         const final = await done;
@@ -8763,8 +10261,8 @@ var init_spawn3 = __esm({
     await init_container();
     init_src5();
     init_poe_agent();
-    spawn4.pretty = async function pretty(service, promptOrOptions, maybeOptions) {
-      const { events, result } = spawn4(service, promptOrOptions, maybeOptions);
+    spawn5.pretty = async function pretty(service, promptOrOptions, maybeOptions) {
+      const { events, result } = spawn5(service, promptOrOptions, maybeOptions);
       await renderAcpStream(events);
       return result;
     };
@@ -9402,7 +10900,7 @@ function registerAgentCommand(program, container) {
     }
     let session;
     try {
-      const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src7(), src_exports));
+      const { createAgentSession: createAgentSession2 } = await Promise.resolve().then(() => (init_src8(), src_exports));
       session = await createAgentSession2({
         model: options.model,
         apiKey: options.apiKey,
@@ -9576,7 +11074,12 @@ function registerSpawnCommand(program, container, options = {}) {
       }
     }
     try {
-      assertMcpSpawnSupport(adapter.label, canonicalService, mcpServers);
+      assertMcpSpawnSupport(
+        adapter.label,
+        canonicalService,
+        adapter.supportsMcpSpawn === true,
+        mcpServers
+      );
       if (flags.dryRun) {
         await spawnCore(container, canonicalService, spawnOptions, {
           dryRun: true,
@@ -9593,7 +11096,7 @@ function registerSpawnCommand(program, container, options = {}) {
       if (!proceed) {
         return;
       }
-      const { events, result } = spawn4(canonicalService, {
+      const { events, result } = spawn5(canonicalService, {
         prompt: spawnOptions.prompt,
         args: spawnOptions.args,
         model: spawnOptions.model,
@@ -9677,14 +11180,14 @@ function parseMcpSpawnConfig(input) {
       "--mcp-config must be valid JSON in this shape: {name: {command, args?, env?}}"
     );
   }
-  if (!isObjectRecord3(parsed)) {
+  if (!isObjectRecord5(parsed)) {
     throw new ValidationError(
       "--mcp-config must be an object in this shape: {name: {command, args?, env?}}"
     );
   }
   const servers = {};
   for (const [name, value] of Object.entries(parsed)) {
-    if (!isObjectRecord3(value)) {
+    if (!isObjectRecord5(value)) {
       throw new ValidationError(
         `--mcp-config entry "${name}" must be an object: {command, args?, env?}`
       );
@@ -9714,7 +11217,7 @@ function parseMcpSpawnConfig(input) {
     }
     let env;
     if ("env" in value && value.env !== void 0) {
-      if (!isObjectRecord3(value.env)) {
+      if (!isObjectRecord5(value.env)) {
         throw new ValidationError(
           `--mcp-config entry "${name}".env must be an object of string values`
         );
@@ -9737,11 +11240,11 @@ function parseMcpSpawnConfig(input) {
   }
   return Object.keys(servers).length > 0 ? servers : void 0;
 }
-function assertMcpSpawnSupport(label, service, servers) {
+function assertMcpSpawnSupport(label, service, providerSupportsMcpSpawn, servers) {
   if (!servers || Object.keys(servers).length === 0) {
     return;
   }
-  if (supportsMcpAtSpawn(service)) {
+  if (supportsMcpAtSpawn(service) || providerSupportsMcpSpawn) {
     return;
   }
   const supported = listMcpSupportedAgents();
@@ -9750,7 +11253,7 @@ function assertMcpSpawnSupport(label, service, servers) {
 Agents with spawn-time MCP support: ${supported.join(", ")}`
   );
 }
-function isObjectRecord3(value) {
+function isObjectRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var init_spawn4 = __esm({
@@ -9777,7 +11280,7 @@ async function research(container, options) {
   });
   const researchPrompt = buildResearchPrompt(options.prompt);
   const mode = options.mode ?? "read";
-  const { events, result } = spawn4(options.agent, {
+  const { events, result } = spawn5(options.agent, {
     prompt: researchPrompt,
     args: options.args ?? [],
     model: options.model,
@@ -10272,7 +11775,7 @@ var init_research2 = __esm({
 });
 
 // src/cli/isolated-env-runner.ts
-import { spawn as spawn5 } from "node:child_process";
+import { spawn as spawn6 } from "node:child_process";
 async function isolatedEnvRunner(input) {
   const details = await resolveIsolatedEnvDetails(
     input.env,
@@ -10297,7 +11800,7 @@ async function isolatedEnvRunner(input) {
     );
     args = buildArgsWithMergedSettings(args, resolvedSettings);
   }
-  const child = spawn5(details.agentBinary, args, {
+  const child = spawn6(details.agentBinary, args, {
     stdio: "inherit",
     env: {
       ...process.env,
@@ -32072,7 +33575,7 @@ var init_content = __esm({
 });
 
 // packages/tiny-stdio-mcp-server/src/index.ts
-var init_src8 = __esm({
+var init_src9 = __esm({
   "packages/tiny-stdio-mcp-server/src/index.ts"() {
     "use strict";
     init_server();
@@ -32376,7 +33879,7 @@ var generateTextSchema, generateImageSchema, generateVideoSchema, generateAudioS
 var init_mcp_server = __esm({
   "src/cli/mcp-server.ts"() {
     "use strict";
-    init_src8();
+    init_src9();
     init_client_instance();
     init_constants();
     generateTextSchema = defineSchema({
@@ -32886,7 +34389,7 @@ var init_apply = __esm({
 });
 
 // packages/agent-mcp-config/src/index.ts
-var init_src9 = __esm({
+var init_src10 = __esm({
   "packages/agent-mcp-config/src/index.ts"() {
     "use strict";
     init_configs2();
@@ -33066,7 +34569,7 @@ var init_mcp2 = __esm({
     init_shared();
     init_mcp_output_format();
     init_command_not_found();
-    init_src9();
+    init_src10();
     init_execution_context();
     DEFAULT_MCP_AGENT = "claude-code";
   }
@@ -33110,7 +34613,7 @@ var init_configs3 = __esm({
 });
 
 // packages/agent-skill-config/src/templates.ts
-import { readFile as readFile3 } from "node:fs/promises";
+import { readFile as readFile2 } from "node:fs/promises";
 async function getTemplates() {
   if (templatesCache) {
     return templatesCache;
@@ -33119,7 +34622,7 @@ async function getTemplates() {
     "./templates/poe-generate.md",
     import.meta.url
   );
-  const poeGenerateTemplate = await readFile3(poeGenerateTemplateUrl, "utf8");
+  const poeGenerateTemplate = await readFile2(poeGenerateTemplateUrl, "utf8");
   templatesCache = {
     "poe-generate.md": poeGenerateTemplate
   };
@@ -33266,7 +34769,7 @@ var init_apply2 = __esm({
 });
 
 // packages/agent-skill-config/src/index.ts
-var init_src10 = __esm({
+var init_src11 = __esm({
   "packages/agent-skill-config/src/index.ts"() {
     "use strict";
     init_configs3();
@@ -33491,7 +34994,7 @@ var init_skill = __esm({
   "src/cli/commands/skill.ts"() {
     "use strict";
     init_src4();
-    init_src10();
+    init_src11();
     init_shared();
     init_command_not_found();
     DEFAULT_SKILL_AGENT = "claude-code";
@@ -33784,7 +35287,7 @@ var init_list = __esm({
 });
 
 // packages/worktree/src/index.ts
-var init_src11 = __esm({
+var init_src12 = __esm({
   "packages/worktree/src/index.ts"() {
     "use strict";
     init_create();
@@ -33941,6 +35444,47 @@ function normalizeStatus(value) {
     `Invalid story status "${value}". Expected one of: open, in_progress, done`
   );
 }
+function normalizeRequirementStatus(value) {
+  if (value === void 0 || value === null) return "pending";
+  if (typeof value !== "string") throw new Error("Invalid requirement status: expected string");
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) return "pending";
+  if (normalized === "pending") return "pending";
+  if (normalized === "verifying") return "verifying";
+  if (normalized === "passed") return "passed";
+  if (normalized === "failed") return "failed";
+  throw new Error(
+    `Invalid requirement status "${value}". Expected one of: pending, verifying, passed, failed`
+  );
+}
+function parseScenario(value, index, reqIndex) {
+  if (!isRecord5(value)) throw new Error(`Invalid requirements[${reqIndex}].scenarios[${index}]: expected object`);
+  return {
+    name: asRequiredString(value.name, `requirements[${reqIndex}].scenarios[${index}].name`),
+    when: asRequiredString(value.when, `requirements[${reqIndex}].scenarios[${index}].when`),
+    then: asRequiredString(value.then, `requirements[${reqIndex}].scenarios[${index}].then`)
+  };
+}
+function parseRequirement(value, index) {
+  if (!isRecord5(value)) throw new Error(`Invalid requirements[${index}]: expected object`);
+  const scenariosValue = value.scenarios;
+  const scenarios = scenariosValue === void 0 || scenariosValue === null ? [] : scenariosValue;
+  if (!Array.isArray(scenarios)) {
+    throw new Error(`Invalid requirements[${index}].scenarios: expected array`);
+  }
+  const id = asOptionalString(value.id, `requirements[${index}].id`) ?? `R-${String(index + 1).padStart(3, "0")}`;
+  const req = {
+    id,
+    title: asOptionalString(value.title, `requirements[${index}].title`) ?? `Requirement ${id}`,
+    description: asOptionalString(value.description, `requirements[${index}].description`),
+    scenarios: scenarios.map((s, i) => parseScenario(s, i, index)),
+    status: normalizeRequirementStatus(value.status),
+    verifiedAt: asIsoString(value.verifiedAt, `requirements[${index}].verifiedAt`)
+  };
+  const extra = collectExtra(value, KNOWN_REQUIREMENT_KEYS);
+  if (extra) req._extra = extra;
+  return req;
+}
 function collectExtra(record2, knownKeys) {
   const extra = {};
   let hasExtra = false;
@@ -33988,6 +35532,11 @@ function parsePlan(yamlContent) {
   if (!Array.isArray(stories)) {
     throw new Error("Invalid stories: expected array");
   }
+  const requirementsValue = doc.requirements;
+  const requirements = requirementsValue === void 0 || requirementsValue === null ? [] : requirementsValue;
+  if (!Array.isArray(requirements)) {
+    throw new Error("Invalid requirements: expected array");
+  }
   const KNOWN_PLAN_KEYS = /* @__PURE__ */ new Set([
     "version",
     "project",
@@ -33995,6 +35544,7 @@ function parsePlan(yamlContent) {
     "goals",
     "nonGoals",
     "qualityGates",
+    "requirements",
     "stories"
   ]);
   const plan = {
@@ -34004,13 +35554,14 @@ function parsePlan(yamlContent) {
     goals: asStringArray(doc.goals, "goals"),
     nonGoals: asStringArray(doc.nonGoals, "nonGoals"),
     qualityGates: asStringArray(doc.qualityGates, "qualityGates"),
+    requirements: requirements.map((r, i) => parseRequirement(r, i)),
     stories: stories.map((s, i) => parseStory(s, i))
   };
   const extra = collectExtra(doc, KNOWN_PLAN_KEYS);
   if (extra) plan._extra = extra;
   return plan;
 }
-var KNOWN_STORY_KEYS;
+var KNOWN_STORY_KEYS, KNOWN_REQUIREMENT_KEYS;
 var init_parser = __esm({
   "packages/ralph/src/plan/parser.ts"() {
     "use strict";
@@ -34025,6 +35576,14 @@ var init_parser = __esm({
       "completedAt",
       "updatedAt"
     ]);
+    KNOWN_REQUIREMENT_KEYS = /* @__PURE__ */ new Set([
+      "id",
+      "title",
+      "description",
+      "scenarios",
+      "status",
+      "verifiedAt"
+    ]);
   }
 });
 
@@ -34052,8 +35611,33 @@ function serializeStory(story) {
   if (story.updatedAt !== void 0) {
     ordered.updatedAt = story.updatedAt;
   }
-  if (story._extra) {
-    Object.assign(ordered, story._extra);
+  if (story._extra) {
+    Object.assign(ordered, story._extra);
+  }
+  return ordered;
+}
+function serializeScenario(scenario) {
+  return {
+    name: scenario.name,
+    when: scenario.when,
+    then: scenario.then
+  };
+}
+function serializeRequirement(req) {
+  const ordered = {
+    id: req.id,
+    title: req.title
+  };
+  if (req.description !== void 0) {
+    ordered.description = req.description;
+  }
+  ordered.scenarios = req.scenarios.map(serializeScenario);
+  ordered.status = req.status;
+  if (req.verifiedAt !== void 0) {
+    ordered.verifiedAt = req.verifiedAt;
+  }
+  if (req._extra) {
+    Object.assign(ordered, req._extra);
   }
   return ordered;
 }
@@ -34068,6 +35652,9 @@ function serializePlan(prd) {
   ordered.goals = prd.goals;
   ordered.nonGoals = prd.nonGoals;
   ordered.qualityGates = prd.qualityGates;
+  if (prd.requirements.length > 0) {
+    ordered.requirements = prd.requirements.map(serializeRequirement);
+  }
   if (prd._extra) {
     Object.assign(ordered, prd._extra);
   }
@@ -34109,6 +35696,31 @@ var init_renderer2 = __esm({
   }
 });
 
+// packages/ralph/src/prompt/resolver.ts
+import { resolve as resolvePath3, join as join3 } from "node:path";
+async function resolveTemplate(name, options) {
+  const paths = [
+    resolvePath3(options.cwd, ".agents/poe-code-ralph", name)
+  ];
+  if (options.homeDir) {
+    paths.push(join3(options.homeDir, ".poe-code", "ralph", name));
+  }
+  paths.push(join3(options.bundledDir, name));
+  for (const p of paths) {
+    try {
+      return await options.fs.readFile(p, "utf8");
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+var init_resolver = __esm({
+  "packages/ralph/src/prompt/resolver.ts"() {
+    "use strict";
+  }
+});
+
 // packages/ralph/src/story/selector.ts
 function isStaleStory(story, nowMs, staleSeconds) {
   if (!Number.isFinite(staleSeconds) || staleSeconds < 0) return false;
@@ -34236,9 +35848,67 @@ var init_updater = __esm({
   }
 });
 
-// packages/ralph/src/run/metadata.ts
+// packages/ralph/src/requirement/selector.ts
+function selectRequirement(plan, options = {}) {
+  const ignoreIds = options.ignoreIds ?? null;
+  return plan.requirements.find((r) => r.status !== "passed" && (!ignoreIds || !ignoreIds.has(r.id))) ?? null;
+}
+var init_selector2 = __esm({
+  "packages/ralph/src/requirement/selector.ts"() {
+    "use strict";
+  }
+});
+
+// packages/ralph/src/requirement/updater.ts
 import { dirname as dirname5 } from "node:path";
 import * as fsPromises6 from "node:fs/promises";
+function lockPlanFile3(path22) {
+  return lockFile(path22, { retries: 20, minTimeout: 25, maxTimeout: 250 });
+}
+function findRequirement(plan, requirementId) {
+  const req = plan.requirements.find((r) => r.id === requirementId);
+  if (!req) {
+    throw new Error(`Requirement not found: ${requirementId}`);
+  }
+  return req;
+}
+async function updateRequirementStatus(planPath, requirementId, status, options = {}) {
+  const fs3 = options.fs ?? fsPromises6;
+  const lock = options.lock ?? lockPlanFile3;
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  await fs3.mkdir(dirname5(planPath), { recursive: true });
+  const release = await lock(planPath);
+  try {
+    const yaml = await fs3.readFile(planPath, "utf8");
+    const plan = parsePlan(yaml);
+    const req = findRequirement(plan, requirementId);
+    req.status = status;
+    if (status === "passed") {
+      req.verifiedAt = now.toISOString();
+    } else if (status === "pending" || status === "failed") {
+      req.verifiedAt = void 0;
+    }
+    await writePlan(planPath, plan, {
+      fs: fs3,
+      lock: async () => async () => {
+      }
+    });
+  } finally {
+    await release();
+  }
+}
+var init_updater2 = __esm({
+  "packages/ralph/src/requirement/updater.ts"() {
+    "use strict";
+    init_lock();
+    init_parser();
+    init_writer();
+  }
+});
+
+// packages/ralph/src/run/metadata.ts
+import { dirname as dirname6 } from "node:path";
+import * as fsPromises7 from "node:fs/promises";
 function formatCommitLine(commit) {
   const hash2 = commit.hash.length > 7 ? commit.hash.slice(0, 7) : commit.hash;
   return `${hash2} ${commit.subject}`;
@@ -34257,8 +35927,8 @@ function appendSection(lines, title, items, options) {
   lines.push("");
 }
 async function writeRunMeta(path22, metadata, options = {}) {
-  const fs3 = options.fs ?? fsPromises6;
-  await fs3.mkdir(dirname5(path22), { recursive: true });
+  const fs3 = options.fs ?? fsPromises7;
+  await fs3.mkdir(dirname6(path22), { recursive: true });
   const lines = [];
   lines.push("# Ralph Run Summary", "");
   lines.push(`- Run ID: ${metadata.runId}`);
@@ -34382,8 +36052,8 @@ var init_overbaking = __esm({
 });
 
 // packages/ralph/src/build/loop.ts
-import { basename as basename2, dirname as dirname6, resolve as resolvePath3 } from "node:path";
-import * as fsPromises7 from "node:fs/promises";
+import { basename as basename2, dirname as dirname7, resolve as resolvePath4 } from "node:path";
+import * as fsPromises8 from "node:fs/promises";
 import { execSync as execSync2 } from "node:child_process";
 async function defaultStreamingSpawn(agentId, options) {
   const { events, done } = spawnStreaming({
@@ -34411,8 +36081,8 @@ async function defaultStreamingSpawn(agentId, options) {
   };
 }
 function absPath(cwd, path22) {
-  if (!path22) return resolvePath3(cwd);
-  return path22.startsWith("/") ? path22 : resolvePath3(cwd, path22);
+  if (!path22) return resolvePath4(cwd);
+  return path22.startsWith("/") ? path22 : resolvePath4(cwd, path22);
 }
 function pad2(value) {
   return value < 10 ? `0${value}` : String(value);
@@ -34459,10 +36129,10 @@ async function appendToErrorsLog(fs3, errorsLogPath, message) {
       throw error2;
     }
   }
-  await fs3.mkdir(dirname6(errorsLogPath), { recursive: true });
+  await fs3.mkdir(dirname7(errorsLogPath), { recursive: true });
   await fs3.writeFile(errorsLogPath, `${previous}${next}`, { encoding: "utf8" });
 }
-function lockPlanFile3(path22) {
+function lockPlanFile4(path22) {
   return lockFile(path22, { retries: 20, minTimeout: 25, maxTimeout: 250 });
 }
 function getCurrentBranch(cwd) {
@@ -34490,7 +36160,7 @@ function defaultExec(command, options) {
   return Promise.resolve({ stdout: result, stderr: "" });
 }
 async function defaultCopyFile(src, dest) {
-  await fsPromises7.copyFile(src, dest);
+  await fsPromises8.copyFile(src, dest);
 }
 function formatQualityGates(gates) {
   if (gates.length === 0) return "- (none)";
@@ -34539,6 +36209,41 @@ async function selectStoryFromFile(planPath, options) {
     await release();
   }
 }
+function formatRequirementBlock(req) {
+  const description = req.description?.trim() ? req.description.trim() : "(none)";
+  const scenarios = req.scenarios.length === 0 ? "- (none)" : req.scenarios.map((s) => `- **${s.name}**
+  When: ${s.when}
+  Then: ${s.then}`).join("\n");
+  return [
+    `### ${req.id}: ${req.title}`,
+    `Status: ${req.status}`,
+    "",
+    "Description:",
+    description,
+    "",
+    "Scenarios:",
+    scenarios,
+    ""
+  ].join("\n");
+}
+async function selectRequirementFromFile(planPath, options) {
+  const release = await options.lock(planPath);
+  try {
+    const raw = await options.fs.readFile(planPath, "utf8");
+    const plan = parsePlan(raw);
+    const selected = selectRequirement(plan, { ignoreIds: options.ignoreRequirementIds });
+    if (!selected) return null;
+    selected.status = "verifying";
+    await writePlan(planPath, plan, {
+      fs: options.fs,
+      lock: async () => async () => {
+      }
+    });
+    return { requirement: selected, qualityGates: plan.qualityGates };
+  } finally {
+    await release();
+  }
+}
 function formatOverbakeWarning(args) {
   return [
     `[OVERBAKE] ${args.storyId}: ${args.storyTitle}`,
@@ -34563,9 +36268,9 @@ async function defaultPromptOverbake(args) {
   return value;
 }
 async function buildLoop(options) {
-  const fs3 = options.deps?.fs ?? fsPromises7;
-  const lock = options.deps?.lock ?? lockPlanFile3;
-  const spawn6 = options.deps?.spawn ?? defaultStreamingSpawn;
+  const fs3 = options.deps?.fs ?? fsPromises8;
+  const lock = options.deps?.lock ?? lockPlanFile4;
+  const spawn7 = options.deps?.spawn ?? defaultStreamingSpawn;
   const git = options.deps?.git ?? {
     getHead,
     getCommitList,
@@ -34619,7 +36324,7 @@ async function buildLoop(options) {
       });
       worktreeBranch = entry.branch;
       const worktreePath = entry.path;
-      const symlinkFn = fs3.symlink ?? ((target, path22) => fsPromises7.symlink(target, path22));
+      const symlinkFn = fs3.symlink ?? ((target, path22) => fsPromises8.symlink(target, path22));
       const exec2 = worktreeDeps.exec;
       const dirsToLink = [".poe-code-ralph", ".agents/poe-code-ralph"];
       for (const dir of dirsToLink) {
@@ -34630,14 +36335,14 @@ async function buildLoop(options) {
         }
         const src = absPath(originalCwd, dir);
         const dest = absPath(worktreePath, dir);
-        await fs3.mkdir(dirname6(dest), { recursive: true });
+        await fs3.mkdir(dirname7(dest), { recursive: true });
         try {
           await symlinkFn(src, dest);
         } catch {
         }
       }
       const destPlanPath = absPath(worktreePath, options.planPath);
-      await fs3.mkdir(dirname6(destPlanPath), { recursive: true });
+      await fs3.mkdir(dirname7(destPlanPath), { recursive: true });
       await copyFile3(planPath, destPlanPath);
       const copiedRaw = await fs3.readFile(destPlanPath, "utf8");
       const copiedPlan = parsePlan(copiedRaw);
@@ -34673,6 +36378,7 @@ async function buildLoop(options) {
   }
   const runsDir = absPath(cwd, ".poe-code-ralph/runs");
   const runId = options.deps?.runId ?? createRunId(nowFn());
+  const loopStartTime = nowFn();
   const overbaking = new OverbakingDetector({ threshold: options.maxFailures });
   const skippedStoryIds = /* @__PURE__ */ new Set();
   const storiesDone = [];
@@ -34688,19 +36394,13 @@ async function buildLoop(options) {
       ignoreStoryIds: skippedStoryIds
     });
     if (!selection) {
-      return finalizeWorktreeResult({
-        runId,
-        iterationsCompleted: iterations.length,
-        storiesDone,
-        iterations,
-        stopReason: "no_actionable_stories"
-      });
+      break;
     }
     const story = selection.story;
     const storyBlock = formatStoryBlock(story);
-    const logPath = resolvePath3(runsDir, `run-${runId}-iter-${i}.log`);
-    const metaPath = resolvePath3(runsDir, `run-${runId}-iter-${i}.md`);
-    const renderedPromptPath = resolvePath3(
+    const logPath = resolvePath4(runsDir, `run-${runId}-iter-${i}.log`);
+    const metaPath = resolvePath4(runsDir, `run-${runId}-iter-${i}.md`);
+    const renderedPromptPath = resolvePath4(
       absPath(cwd, ".poe-code-ralph/.tmp"),
       `prompt-build-${runId}-iter-${i}.md`
     );
@@ -34725,7 +36425,7 @@ async function buildLoop(options) {
       STORY_BLOCK: storyBlock,
       QUALITY_GATES: formatQualityGates(selection.qualityGates)
     });
-    await fs3.mkdir(dirname6(renderedPromptPath), { recursive: true });
+    await fs3.mkdir(dirname7(renderedPromptPath), { recursive: true });
     await fs3.writeFile(renderedPromptPath, prompt, { encoding: "utf8" });
     stdout.write(`[${i}/${options.maxIterations}] ${story.title}
 `);
@@ -34734,7 +36434,7 @@ async function buildLoop(options) {
     let stderrForErrorsLog;
     let overbakeAction = null;
     try {
-      const result = await spawn6(options.agent, {
+      const result = await spawn7(options.agent, {
         prompt,
         cwd,
         model: options.model,
@@ -34765,7 +36465,7 @@ ${agentStderr}` : ""
       stderrForErrorsLog = combinedOutput;
       status = "failure";
     }
-    await fs3.mkdir(dirname6(logPath), { recursive: true });
+    await fs3.mkdir(dirname7(logPath), { recursive: true });
     await fs3.writeFile(logPath, combinedOutput, { encoding: "utf8" });
     if (status === "failure" && stderrForErrorsLog.trim().length > 0) {
       await appendToErrorsLog(fs3, errorsLogPath, stderrForErrorsLog);
@@ -34866,16 +36566,239 @@ ${agentStderr}` : ""
       });
     }
   }
+  if (iterations.length >= options.maxIterations) {
+    return finalizeWorktreeResult({
+      runId,
+      iterationsCompleted: iterations.length,
+      storiesDone,
+      iterations,
+      stopReason: "max_iterations"
+    });
+  }
+  const verifyTemplate = await resolveTemplate("PROMPT_verify.md", {
+    fs: fs3,
+    cwd,
+    bundledDir: absPath(cwd, ".agents/poe-code-ralph")
+  });
+  if (!verifyTemplate) {
+    return finalizeWorktreeResult({
+      runId,
+      iterationsCompleted: iterations.length,
+      storiesDone,
+      iterations,
+      stopReason: "no_actionable_stories"
+    });
+  }
+  const currentPlan = parsePlan(await fs3.readFile(planPath, "utf8"));
+  const hasPendingRequirements = currentPlan.requirements.some((r) => r.status !== "passed");
+  if (!hasPendingRequirements) {
+    return finalizeWorktreeResult({
+      runId,
+      iterationsCompleted: iterations.length,
+      storiesDone,
+      iterations,
+      stopReason: "no_actionable_stories"
+    });
+  }
+  const skippedRequirementIds = /* @__PURE__ */ new Set();
+  for (let vi = iterations.length + 1; vi <= options.maxIterations; vi++) {
+    const iterationStart = nowFn();
+    const headBefore = git.getHead(cwd);
+    const reqSelection = await selectRequirementFromFile(planPath, {
+      fs: fs3,
+      lock,
+      now: iterationStart,
+      ignoreRequirementIds: skippedRequirementIds
+    });
+    if (!reqSelection) {
+      return finalizeWorktreeResult({
+        runId,
+        iterationsCompleted: iterations.length,
+        storiesDone,
+        iterations,
+        stopReason: "all_verified"
+      });
+    }
+    const req = reqSelection.requirement;
+    const reqBlock = formatRequirementBlock(req);
+    const logPath = resolvePath4(runsDir, `run-${runId}-iter-${vi}.log`);
+    const metaPath = resolvePath4(runsDir, `run-${runId}-iter-${vi}.md`);
+    const renderedPromptPath = resolvePath4(
+      absPath(cwd, ".poe-code-ralph/.tmp"),
+      `prompt-verify-${runId}-iter-${vi}.md`
+    );
+    const prompt = renderPrompt(verifyTemplate, {
+      PLAN_PATH: planPath,
+      PROGRESS_PATH: progressPath,
+      REPO_ROOT: cwd,
+      GUARDRAILS_PATH: guardrailsPath,
+      ERRORS_LOG_PATH: errorsLogPath,
+      ACTIVITY_LOG_PATH: activityLogPath,
+      GUARDRAILS_REF: guardrailsRef,
+      CONTEXT_REF: contextRef,
+      ACTIVITY_CMD: activityCmd,
+      COMMIT: options.commit,
+      RUN_ID: runId,
+      ITERATION: vi,
+      RUN_LOG_PATH: logPath,
+      RUN_META_PATH: metaPath,
+      REQUIREMENT_ID: req.id,
+      REQUIREMENT_TITLE: req.title,
+      REQUIREMENT_BLOCK: reqBlock,
+      QUALITY_GATES: formatQualityGates(reqSelection.qualityGates)
+    });
+    await fs3.mkdir(dirname7(renderedPromptPath), { recursive: true });
+    await fs3.writeFile(renderedPromptPath, prompt, { encoding: "utf8" });
+    stdout.write(`[${vi}/${options.maxIterations}] Verify: ${req.title}
+`);
+    let status;
+    let combinedOutput;
+    let stderrForErrorsLog;
+    try {
+      const result = await spawn7(options.agent, {
+        prompt,
+        cwd,
+        model: options.model,
+        mode: "yolo",
+        useStdin: true
+      });
+      const agentStdout = result.stdout ?? "";
+      const agentStderr = result.stderr ?? "";
+      stderrForErrorsLog = agentStderr;
+      combinedOutput = [
+        agentStdout ? `# stdout
+${agentStdout}` : "",
+        agentStderr ? `# stderr
+${agentStderr}` : ""
+      ].filter(Boolean).join("\n");
+      if (result.exitCode !== 0) {
+        status = "failure";
+      } else if (detectCompletion(agentStdout)) {
+        status = "success";
+      } else {
+        status = "incomplete";
+      }
+    } catch (error2) {
+      const detail = error2 instanceof Error ? error2.message : `Unknown error: ${String(error2)}`;
+      combinedOutput = `Agent execution error: ${detail}`;
+      stderrForErrorsLog = combinedOutput;
+      status = "failure";
+    }
+    await fs3.mkdir(dirname7(logPath), { recursive: true });
+    await fs3.writeFile(logPath, combinedOutput, { encoding: "utf8" });
+    if (status === "failure" && stderrForErrorsLog.trim().length > 0) {
+      await appendToErrorsLog(fs3, errorsLogPath, stderrForErrorsLog);
+    }
+    const overbakeEvent = overbaking.record(req.id, status);
+    let overbakeAction = null;
+    if (overbakeEvent.shouldWarn) {
+      const warning = formatOverbakeWarning({
+        storyId: req.id,
+        storyTitle: req.title,
+        consecutiveFailures: overbakeEvent.consecutiveFailures,
+        threshold: overbakeEvent.threshold
+      });
+      stderr.write(warning);
+      await appendToErrorsLog(fs3, errorsLogPath, warning);
+    }
+    if (overbakeEvent.overbaked) {
+      if (options.pauseOnOverbake) {
+        overbakeAction = await promptOverbake({
+          storyId: req.id,
+          storyTitle: req.title,
+          consecutiveFailures: overbakeEvent.consecutiveFailures,
+          threshold: overbakeEvent.threshold
+        });
+      } else {
+        overbakeAction = "skip";
+      }
+      if (overbakeAction === "skip") {
+        skippedRequirementIds.add(req.id);
+      }
+    }
+    const iterationEnd = nowFn();
+    const durationSeconds = Math.max(
+      0,
+      Math.round((iterationEnd.getTime() - iterationStart.getTime()) / 1e3)
+    );
+    if (status === "success") {
+      await updateRequirementStatus(planPath, req.id, "passed", {
+        fs: fs3,
+        lock,
+        now: iterationEnd
+      });
+    } else {
+      await updateRequirementStatus(planPath, req.id, "pending", {
+        fs: fs3,
+        lock,
+        now: iterationEnd
+      });
+    }
+    const headAfter = git.getHead(cwd);
+    const dirtyFiles = git.getDirtyFiles(cwd);
+    const commits = headBefore && headAfter && headBefore !== headAfter ? git.getCommitList(cwd, headBefore, headAfter) : [];
+    const changedFiles = headBefore && headAfter && headBefore !== headAfter ? git.getChangedFiles(cwd, headBefore, headAfter) : [];
+    await writeRunMeta(
+      metaPath,
+      {
+        runId,
+        iteration: vi,
+        mode: "verify",
+        storyId: req.id,
+        storyTitle: req.title,
+        started: formatTimestamp2(iterationStart),
+        ended: formatTimestamp2(iterationEnd),
+        duration: `${durationSeconds}s`,
+        status,
+        logPath,
+        overbaking: {
+          maxFailures: overbakeEvent.threshold,
+          consecutiveFailures: overbakeEvent.consecutiveFailures,
+          triggered: overbakeEvent.overbaked,
+          action: overbakeAction ?? void 0
+        },
+        git: {
+          headBefore,
+          headAfter,
+          commits,
+          changedFiles,
+          dirtyFiles
+        }
+      },
+      { fs: fs3 }
+    );
+    iterations.push({
+      iteration: vi,
+      storyId: req.id,
+      storyTitle: req.title,
+      status,
+      logPath,
+      metaPath
+    });
+    if (overbakeAction === "abort") {
+      return finalizeWorktreeResult({
+        runId,
+        iterationsCompleted: iterations.length,
+        storiesDone,
+        iterations,
+        stopReason: "overbake_abort"
+      });
+    }
+  }
+  const finalPlan = parsePlan(await fs3.readFile(planPath, "utf8"));
+  const allPassed = finalPlan.requirements.every((r) => r.status === "passed");
   return finalizeWorktreeResult({
     runId,
     iterationsCompleted: iterations.length,
     storiesDone,
     iterations,
-    stopReason: "max_iterations"
+    stopReason: allPassed ? "all_verified" : "max_iterations"
   });
   async function finalizeWorktreeResult(result) {
+    const totalDurationMs = Math.max(0, nowFn().getTime() - loopStartTime.getTime());
+    const fullResult = { ...result, totalDurationMs };
     if (!options.worktree?.enabled || !worktreeName) {
-      return result;
+      return fullResult;
     }
     const worktreeDeps = options.deps?.worktree ?? {
       fs: {
@@ -34889,7 +36812,7 @@ ${agentStderr}` : ""
     await updateWorktreeStatus(registryFile, worktreeName, worktreeStatus, {
       fs: worktreeDeps.fs
     });
-    result.worktreeBranch = worktreeBranch;
+    fullResult.worktreeBranch = worktreeBranch;
     if (worktreeBranch) {
       const mergeHint = [
         "",
@@ -34900,7 +36823,7 @@ ${agentStderr}` : ""
       ].join("\n");
       stdout.write(mergeHint);
     }
-    return result;
+    return fullResult;
   }
 }
 var init_loop = __esm({
@@ -34910,14 +36833,17 @@ var init_loop = __esm({
     init_src5();
     init_src4();
     init_src2();
-    init_src11();
+    init_src12();
     init_detector();
     init_utils2();
     init_parser();
     init_writer();
     init_renderer2();
+    init_resolver();
     init_selector();
     init_updater();
+    init_selector2();
+    init_updater2();
     init_metadata();
     init_overbaking();
   }
@@ -34925,7 +36851,7 @@ var init_loop = __esm({
 
 // packages/ralph/src/plan/resolver.ts
 import path17 from "node:path";
-import * as fsPromises8 from "node:fs/promises";
+import * as fsPromises9 from "node:fs/promises";
 function isPlanCandidateFile(fileName) {
   const lower = fileName.toLowerCase();
   if (!lower.startsWith("plan")) {
@@ -34967,9 +36893,9 @@ async function listPlanCandidates(fs3, cwd) {
 }
 async function resolvePlanPath(options) {
   const fs3 = options.fs ?? {
-    readdir: fsPromises8.readdir,
-    stat: fsPromises8.stat,
-    readFile: fsPromises8.readFile
+    readdir: fsPromises9.readdir,
+    stat: fsPromises9.stat,
+    readFile: fsPromises9.readFile
   };
   const cwd = options.cwd;
   const provided = options.plan?.trim();
@@ -35020,7 +36946,7 @@ async function resolvePlanPath(options) {
   }
   return selection;
 }
-var init_resolver = __esm({
+var init_resolver2 = __esm({
   "packages/ralph/src/plan/resolver.ts"() {
     "use strict";
     init_src4();
@@ -35031,7 +36957,7 @@ var init_resolver = __esm({
 
 // packages/ralph/src/plan/generator.ts
 import path18 from "node:path";
-import * as fsPromises9 from "node:fs/promises";
+import * as fsPromises10 from "node:fs/promises";
 var PLAN_PROMPT_TEMPLATE;
 var init_generator = __esm({
   "packages/ralph/src/plan/generator.ts"() {
@@ -35085,8 +37011,8 @@ var init_generator = __esm({
 });
 
 // packages/ralph/src/log/activity.ts
-import { dirname as dirname7 } from "node:path";
-import * as fsPromises10 from "node:fs/promises";
+import { dirname as dirname8 } from "node:path";
+import * as fsPromises11 from "node:fs/promises";
 function pad22(value) {
   return value < 10 ? `0${value}` : String(value);
 }
@@ -35111,8 +37037,8 @@ function validateLogPath(path22) {
 }
 async function logActivity(path22, message, options = {}) {
   validateLogPath(path22);
-  const fs3 = options.fs ?? fsPromises10;
-  const parent = dirname7(path22);
+  const fs3 = options.fs ?? fsPromises11;
+  const parent = dirname8(path22);
   if (parent && parent !== ".") {
     await fs3.mkdir(parent, { recursive: true });
   }
@@ -35133,7 +37059,7 @@ var init_activity = __esm({
 
 // packages/ralph/src/config/loader.ts
 import path19 from "node:path";
-import * as fsPromises11 from "node:fs/promises";
+import * as fsPromises12 from "node:fs/promises";
 import YAML from "yaml";
 function isPlainObject2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -35237,7 +37163,7 @@ function mergeConfigs(base, override) {
   return result;
 }
 async function loadConfig(cwd, deps) {
-  const fs3 = deps?.fs ?? fsPromises11;
+  const fs3 = deps?.fs ?? fsPromises12;
   const sources = [];
   let merged = {};
   if (deps?.homeDir) {
@@ -35270,12 +37196,12 @@ async function ralphBuild(options) {
     cwd: options.cwd ?? process.cwd()
   });
 }
-var init_src12 = __esm({
+var init_src13 = __esm({
   "packages/ralph/src/index.ts"() {
     "use strict";
     init_loop();
     init_parser();
-    init_resolver();
+    init_resolver2();
     init_generator();
     init_activity();
     init_loader();
@@ -35359,7 +37285,7 @@ var init_ralph_worktree = __esm({
   "src/cli/commands/ralph-worktree.ts"() {
     "use strict";
     init_src4();
-    init_src11();
+    init_src12();
     init_src5();
     init_src2();
     init_errors();
@@ -35889,7 +37815,6 @@ function registerRalphCommand(program, container) {
         resources.logger.success("Dry run complete. No agents spawned.");
         return;
       }
-      const buildStart = Date.now();
       const buildResult = await ralphBuild({
         planPath,
         progressPath: config2.progressPath,
@@ -35907,11 +37832,10 @@ function registerRalphCommand(program, container) {
         worktree,
         deps: { stdout: process.stdout }
       });
-      const duration3 = formatDuration(Date.now() - buildStart);
       resources.logger.resolved("Run summary", [
         `Iterations: ${buildResult.iterationsCompleted}/${maxIterations}`,
         `Stories done: ${buildResult.storiesDone.length}`,
-        `Duration: ${duration3}`
+        `Duration: ${formatDuration(buildResult.totalDurationMs)}`
       ].join("\n   "));
       resources.logger.success("Ralph run finished.");
     } finally {
@@ -35930,8 +37854,8 @@ var init_ralph = __esm({
   "src/cli/commands/ralph.ts"() {
     "use strict";
     init_src4();
-    init_src12();
-    init_src10();
+    init_src13();
+    init_src11();
     init_src2();
     init_errors();
     init_shared();
@@ -36447,7 +38371,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "poe-code",
-      version: "3.0.73",
+      version: "3.0.75",
       description: "CLI tool to configure Poe API for developer workflows.",
       type: "module",
       main: "./dist/index.js",
@@ -36961,12 +38885,12 @@ import * as nodeFsSync3 from "node:fs";
 import { realpathSync } from "node:fs";
 import { homedir as homedir5 } from "node:os";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 import chalk13 from "chalk";
 function createCliMain(programFactory) {
   return async function runCli() {
     const homeDir = homedir5();
-    const logDir = join3(homeDir, ".poe-code", "logs");
+    const logDir = join4(homeDir, ".poe-code", "logs");
     const promptRunner = createPromptRunner();
     const shouldLogToStderr = process.env.POE_CODE_STDERR_LOGS === "1" || process.env.POE_CODE_STDERR_LOGS === "true";
     const errorLogger = new ErrorLogger({
@@ -37001,7 +38925,7 @@ function createCliMain(programFactory) {
         } else {
           log2.error(`Error: ${error2.message}`);
           log2.message(
-            `See logs at ${join3(logDir, "errors.log")} for more details.`,
+            `See logs at ${join4(logDir, "errors.log")} for more details.`,
             { symbol: chalk13.magenta("\u25CF") }
           );
         }
@@ -37170,6 +39094,6 @@ export {
   getPoeApiKey,
   isCliInvocation2 as isCliInvocation,
   main,
-  spawn4 as spawn
+  spawn5 as spawn
 };
 //# sourceMappingURL=index.js.map