@pome-sh/cli 0.42.4 → 0.43.1

package/dist/chunk-DFOQGAKS.js

@@ -1,116 +0,0 @@
-import { HostedOrchError, manifestSchema, deriveAgentSlug, SLUG_RE } from './chunk-NNXVR46L.js';
-import { readFile, writeFile } from 'node:fs/promises';
-import { resolve, join, dirname } from 'node:path';
-import { stringify, parse } from 'yaml';
-
-var MANIFEST_JSON = "pome.json";
-var MANIFEST_YAML = "pome.yaml";
-var MANIFEST_YML = "pome.yml";
-var MANIFEST_FILES = [MANIFEST_JSON, MANIFEST_YAML, MANIFEST_YML];
-var SCHEMA_URL = "https://pome.sh/schemas/v1/pome.json";
-var YAML_SCHEMA_COMMENT = `# yaml-language-server: $schema=${SCHEMA_URL}`;
-function formatFor(fileName) {
-  return fileName === MANIFEST_JSON ? "json" : "yaml";
-}
-async function findManifestPath(startDir = process.cwd()) {
-  let dir = resolve(startDir);
-  for (; ; ) {
-    const present = [];
-    for (const fileName of MANIFEST_FILES) {
-      if (await fileExists(join(dir, fileName))) present.push(fileName);
-    }
-    if (present.length > 1) {
-      throw new HostedOrchError(
-        `Multiple pome manifests in ${dir}: ${present.join(", ")}. Keep exactly one (pome.json is canonical).`
-      );
-    }
-    if (present.length === 1) {
-      const fileName = present[0];
-      return { path: join(dir, fileName), format: formatFor(fileName) };
-    }
-    const parent = dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-async function readManifest(startDir = process.cwd()) {
-  const found = await findManifestPath(startDir);
-  if (!found) return null;
-  const text = await readFile(found.path, "utf8");
-  const raw = parseManifestText(text, found);
-  const manifest = validateManifest(raw, found.path);
-  return { ...found, manifest, raw };
-}
-async function readRequiredManifest(startDir = process.cwd()) {
-  const read = await readManifest(startDir);
-  if (!read) {
-    throw new HostedOrchError(
-      `No pome manifest found (${MANIFEST_JSON} or ${MANIFEST_YAML}). Run \`pome init\` first.`
-    );
-  }
-  return read;
-}
-async function writeManifest(path, format, data) {
-  if (format === "json") {
-    await writeFile(path, `${JSON.stringify(data, null, 2)}
-`);
-    return;
-  }
-  const { $schema: _dropped, ...body } = data;
-  await writeFile(path, `${YAML_SCHEMA_COMMENT}
-${stringify(body)}`);
-}
-function parseManifestText(text, found) {
-  let parsed;
-  try {
-    parsed = found.format === "json" ? JSON.parse(text) : parse(text);
-  } catch (err) {
-    throw new HostedOrchError(
-      `${found.path} is not valid ${found.format.toUpperCase()}: ${err instanceof Error ? err.message : String(err)}`
-    );
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    throw new HostedOrchError(`${found.path} is not a ${found.format} object`);
-  }
-  return parsed;
-}
-function validateManifest(raw, path) {
-  const result = manifestSchema.safeParse(raw);
-  if (result.success) return result.data;
-  const slugIssue = result.error.issues.find(
-    (issue) => issue.path[0] === "agent" && issue.path[1] === "slug"
-  );
-  if (slugIssue) {
-    throw new HostedOrchError(slugErrorMessage(raw, path));
-  }
-  const summary = result.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
-  throw new HostedOrchError(`Invalid pome manifest ${path}: ${summary}`);
-}
-function slugErrorMessage(raw, path) {
-  const agent = typeof raw.agent === "object" && raw.agent !== null ? raw.agent : {};
-  const name = typeof agent.name === "string" ? agent.name : "";
-  const badSlug = typeof agent.slug === "string" ? agent.slug : "";
-  const suggestion = deriveAgentSlug(name || badSlug);
-  const base = `Invalid agent.slug in ${path}: must match ${SLUG_RE} (lowercase kebab-case, max 64 chars).`;
-  return suggestion.length > 0 ? `${base} Did you mean "${suggestion}"?` : base;
-}
-function normalizeManifestTwins(manifestTwins) {
-  if (manifestTwins === void 0) return void 0;
-  const out = /* @__PURE__ */ new Set();
-  for (const twin of manifestTwins) {
-    const norm = twin.trim().toLowerCase();
-    if (norm.length > 0) out.add(norm);
-  }
-  return out.size > 0 ? [...out] : void 0;
-}
-async function fileExists(path) {
-  try {
-    await readFile(path, "utf8");
-    return true;
-  } catch (err) {
-    if (err.code === "ENOENT") return false;
-    throw err;
-  }
-}
-
-export { MANIFEST_JSON, findManifestPath, normalizeManifestTwins, readManifest, readRequiredManifest, writeManifest };

package/dist/chunk-JNXZBK3O.js

@@ -1,17 +0,0 @@
-import { randomBytes } from 'node:crypto';
-
-// src/demo/ids.ts
-var NANOID_ALPHABET = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
-function nanoid(size = 21) {
-  const bytes = randomBytes(size);
-  let id = "";
-  for (let i = 0; i < size; i += 1) {
-    id += NANOID_ALPHABET[bytes[i] & 63];
-  }
-  return id;
-}
-function newGroupId() {
-  return `grp_${nanoid(21)}`;
-}
-
-export { newGroupId };

package/dist/chunk-WERG4AUH.js

@@ -1,462 +0,0 @@
-import { parseTaskFile, seedStateForTwin, runAgentCommand, writeRunArtifactsCore } from './chunk-STMGQ7GU.js';
-import { createRecorder, bootTwin } from './chunk-5NPGY73F.js';
-import { getAvailablePort } from './chunk-XDU6TD4O.js';
-import { buildEgressAllowlist, readBlockedEgress } from './chunk-CBFKZZBR.js';
-import { eventSchema } from './chunk-6KJC4BTO.js';
-import { redactSecrets, redactEvent } from './chunk-SG6ZTIMT.js';
-import { serve } from '@hono/node-server';
-import { randomUUID, randomBytes } from 'node:crypto';
-import { mkdir, writeFile, readFile } from 'node:fs/promises';
-import { join, sep, resolve, dirname } from 'node:path';
-import { sign } from 'hono/jwt';
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-
-var LISTENING_REGEX = /listening on 127\.0\.0\.1:(\d+)/;
-async function spawnCaptureServerChild(options) {
-  const execPath = options.execPath ?? process.execPath;
-  const binArgs = options.binArgs ?? defaultBinArgs(options.eventsOut, options.allowHosts, options.egressOut);
-  const readyTimeoutMs = options.readyTimeoutMs ?? 5e3;
-  const shutdownGraceMs = options.shutdownGraceMs ?? 5e3;
-  const child = spawn(execPath, binArgs, {
-    stdio: ["ignore", "ignore", "pipe"],
-    env: process.env
-  });
-  let stderrBuf = "";
-  let resolved = false;
-  const readyPromise = new Promise((resolve2, reject) => {
-    const onData = (chunk) => {
-      stderrBuf += chunk.toString("utf8");
-      if (stderrBuf.length > 8192) stderrBuf = stderrBuf.slice(-8192);
-      const match = LISTENING_REGEX.exec(stderrBuf);
-      if (match) {
-        resolved = true;
-        cleanup();
-        resolve2(Number(match[1]));
-      }
-    };
-    const onExit = (code, signal) => {
-      if (resolved) return;
-      cleanup();
-      const detail = stderrBuf.trim().slice(0, 2048);
-      reject(
-        new Error(
-          `pome capture-server exited (code=${code} signal=${signal}) before printing the listening line.${detail ? `
-stderr: ${detail}` : ""}`
-        )
-      );
-    };
-    const timer = setTimeout(() => {
-      if (resolved) return;
-      cleanup();
-      reject(
-        new Error(
-          `pome capture-server did not start listening within ${readyTimeoutMs}ms.${stderrBuf ? `
-stderr: ${stderrBuf.trim().slice(0, 2048)}` : ""}`
-        )
-      );
-    }, readyTimeoutMs);
-    const cleanup = () => {
-      clearTimeout(timer);
-      child.stderr?.off("data", onData);
-      child.off("exit", onExit);
-    };
-    child.stderr?.on("data", onData);
-    child.once("exit", onExit);
-  });
-  let port;
-  try {
-    port = await readyPromise;
-  } catch (err) {
-    if (!child.killed) child.kill("SIGKILL");
-    throw err;
-  }
-  child.stderr?.on("data", () => {
-  });
-  const pid = child.pid;
-  if (pid === void 0) {
-    child.kill("SIGKILL");
-    throw new Error("pome capture-server child has no pid after boot");
-  }
-  return {
-    port,
-    pid,
-    shutdown: makeShutdown(child, shutdownGraceMs)
-  };
-}
-function defaultBinArgs(eventsOut, allowHosts, egressOut) {
-  const script = process.argv[1];
-  if (typeof script !== "string" || script.length === 0) {
-    throw new Error(
-      "Cannot determine pome binary path (process.argv[1] is empty). Pass `binArgs` explicitly."
-    );
-  }
-  return [script, "capture-server", "--port", "0", "--events-out", eventsOut, ...egressArgs(allowHosts, egressOut)];
-}
-function egressArgs(allowHosts, egressOut) {
-  const args = [];
-  if (allowHosts && allowHosts.length > 0) args.push("--allow", allowHosts.join(","));
-  if (egressOut) args.push("--egress-out", egressOut);
-  return args;
-}
-function makeShutdown(child, graceMs) {
-  let done = null;
-  return () => {
-    if (done) return done;
-    done = new Promise((resolve2) => {
-      if (child.exitCode !== null || child.signalCode !== null) {
-        resolve2();
-        return;
-      }
-      const onExit = () => {
-        clearTimeout(killTimer);
-        resolve2();
-      };
-      child.once("exit", onExit);
-      try {
-        child.kill("SIGTERM");
-      } catch {
-        child.off("exit", onExit);
-        resolve2();
-        return;
-      }
-      const killTimer = setTimeout(() => {
-        if (child.exitCode === null && child.signalCode === null) {
-          try {
-            child.kill("SIGKILL");
-          } catch {
-          }
-        }
-      }, graceMs);
-    });
-    return done;
-  };
-}
-function resolveTwinHttpParents(rows) {
-  const eventIdByToolUseId = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    if (row.kind === "ToolUseEvent") eventIdByToolUseId.set(row.tool_use_id, row.event_id);
-  }
-  if (eventIdByToolUseId.size === 0) return rows;
-  return rows.map((row) => {
-    if (row.kind !== "TwinHttpEvent") return row;
-    if (row.parent_event_id != null) return row;
-    const causingToolUseId = row.tool_call_id ?? row.correlation_id ?? null;
-    if (causingToolUseId === null) return row;
-    const parentEventId = eventIdByToolUseId.get(causingToolUseId);
-    return parentEventId === void 0 ? row : { ...row, parent_event_id: parentEventId };
-  });
-}
-async function mergeAdapterSignalsIntoEvents(signalsPath, eventsJsonlPath) {
-  let rawSignals;
-  try {
-    rawSignals = await readFile(signalsPath, "utf8");
-  } catch {
-    return { appended: 0, dropped: 0 };
-  }
-  let dropped = 0;
-  const signalRows = [];
-  for (const line of rawSignals.split("\n")) {
-    if (line.length === 0) continue;
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      dropped += 1;
-      continue;
-    }
-    const result = eventSchema.safeParse(parsed);
-    if (!result.success) {
-      dropped += 1;
-      continue;
-    }
-    signalRows.push(redactEvent(result.data));
-  }
-  if (signalRows.length === 0) return { appended: 0, dropped };
-  let rawEvents;
-  try {
-    rawEvents = await readFile(eventsJsonlPath, "utf8");
-  } catch {
-    rawEvents = "";
-  }
-  const eventRows = [];
-  const unparseablePassthrough = [];
-  for (const line of rawEvents.split("\n")) {
-    if (line.length === 0) continue;
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      unparseablePassthrough.push(line);
-      continue;
-    }
-    const result = eventSchema.safeParse(parsed);
-    if (result.success) {
-      eventRows.push(redactEvent(result.data));
-    } else {
-      unparseablePassthrough.push(line);
-    }
-  }
-  const merged = resolveTwinHttpParents(eventRows.concat(signalRows));
-  merged.sort((a, b) => a.ts < b.ts ? -1 : a.ts > b.ts ? 1 : 0);
-  const sortedJsonl = merged.map((r) => JSON.stringify(r)).join("\n");
-  const head = unparseablePassthrough.length > 0 ? unparseablePassthrough.join("\n") + "\n" : "";
-  await writeFile(eventsJsonlPath, head + sortedJsonl + "\n");
-  return { appended: signalRows.length, dropped };
-}
-
-// src/runner/runTaskCore.ts
-async function writeRunNoScore(input) {
-  const artifacts = await writeRunArtifactsCore({
-    artifactsDir: input.artifactsDir,
-    runId: input.runId,
-    scenario: input.scenario,
-    startedAt: input.startedAt,
-    completedAt: input.completedAt,
-    stdout: input.agentStdout,
-    stderr: input.agentStderr,
-    exitCode: input.agentExitCode,
-    events: input.events,
-    stateInitial: input.stateInitial,
-    stateFinal: input.stateFinal
-  });
-  const exitCode = input.agentExitCode !== 0 || input.agentTimedOut ? 3 : 0;
-  return { artifacts, exitCode };
-}
-
-// src/runner/runTask.ts
-function closeServer(server) {
-  return new Promise((resolvePromise, reject) => {
-    server.close((err) => err ? reject(err) : resolvePromise());
-  });
-}
-async function runTask(options) {
-  const scenario = await parseTaskFile(options.taskPath);
-  const runId = `run_${randomUUID()}`;
-  const artifactsDir = options.artifactsDir ?? "runs";
-  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const writeRun = writeRunNoScore;
-  const runDir = join(artifactsDir, scenario.slug, runId);
-  await mkdir(runDir, { recursive: true });
-  const signalsPath = join(runDir, "signals.jsonl");
-  await writeFile(signalsPath, "");
-  const signalsPathForEnv = sep === "\\" ? signalsPath.replace(/\\/g, "/") : signalsPath;
-  const eventsJsonlPath = join(runDir, "events.jsonl");
-  await writeFile(eventsJsonlPath, "");
-  const egressAllowHosts = buildEgressAllowlist(process.env, {
-    extraHosts: options.egressExtraHosts
-  });
-  const egressJsonlPath = join(runDir, "egress.jsonl");
-  const captureServer = options.noCapture ? null : await spawnCaptureServerChild({
-    eventsOut: resolve(eventsJsonlPath),
-    allowHosts: egressAllowHosts,
-    egressOut: resolve(egressJsonlPath),
-    execPath: options.captureServerCommand?.execPath,
-    binArgs: options.captureServerCommand ? [
-      ...options.captureServerCommand.prefixArgs,
-      "capture-server",
-      "--port",
-      "0",
-      "--events-out",
-      resolve(eventsJsonlPath),
-      ...egressArgs(egressAllowHosts, resolve(egressJsonlPath))
-    ] : void 0
-  });
-  if (captureServer) options.onCaptureServerSpawned?.(captureServer.pid);
-  const collectBlockedEgress = async () => {
-    if (!captureServer) return [];
-    await captureServer.shutdown();
-    return readBlockedEgress(egressJsonlPath);
-  };
-  const twins = scenario.config.twins.length ? scenario.config.twins : ["github"];
-  const primaryTwin = twins[0];
-  const isMultiTwin = twins.length > 1;
-  const sid = runId;
-  const authSecret = process.env.TWIN_AUTH_SECRET ?? randomBytes(32).toString("hex");
-  process.env.TWIN_AUTH_SECRET = authSecret;
-  const recorder = createRecorder({ eventsPath: eventsJsonlPath });
-  const booted = [];
-  const twinEnv = {};
-  const tokenEnvNames = /* @__PURE__ */ new Set();
-  const stateInitialByTwin = {};
-  let mergedClaims = {};
-  for (const twin of twins) {
-    const port = await getAvailablePort();
-    const baseUrl = `http://127.0.0.1:${port}`;
-    const harness = await bootTwin({
-      twin,
-      seedState: seedStateForTwin(scenario, twin),
-      runId,
-      twinBaseUrl: baseUrl,
-      recorder
-    });
-    stateInitialByTwin[twin] = await harness.exportState();
-    const sessionBase = `${baseUrl}/s/${sid}`;
-    twinEnv[`POME_${harness.envName}_REST_URL`] = sessionBase;
-    twinEnv[`POME_${harness.envName}_MCP_URL`] = `${sessionBase}/mcp`;
-    if (harness.tokenEnvName) tokenEnvNames.add(harness.tokenEnvName);
-    mergedClaims = { ...mergedClaims, ...harness.extraClaims ?? {} };
-    const server = serve({ fetch: harness.app.fetch, port, hostname: "127.0.0.1" });
-    booted.push({ twin, harness, server });
-  }
-  const stateInitial = stateInitialByTwin[primaryTwin];
-  const token = await sign(
-    {
-      sid,
-      team_id: "tm_local",
-      // The self-host agent acts as `pome-agent`, the collaborator the twin
-      // seeds onto every repo. Without a login claim the REST merge gate
-      // (which checks the authenticated user has push access) rejects merges —
-      // the MCP merge path calls the domain directly and never hit this, so it
-      // was invisible until a scripted REST agent needed to merge.
-      login: "pome-agent",
-      // Twin-supplied claims (e.g. Stripe's `account_id`, so the token resolves
-      // to the account the seed data lives in) — merged across all twins.
-      // github/slack supply none.
-      ...mergedClaims,
-      exp: Math.floor(Date.now() / 1e3) + Math.max(scenario.config.timeout * 2, 600)
-    },
-    authSecret
-  );
-  const proxyEnv = captureServer ? {
-    // Agent's outbound traffic flows through the capture-server.
-    // Twin traffic is localhost, NO_PROXY excludes it so it stays a
-    // TwinHttpEvent (recorded in-process) and isn't double-counted as a
-    // proxy-captured LlmCallEvent.
-    HTTP_PROXY: `http://127.0.0.1:${captureServer.port}`,
-    HTTPS_PROXY: `http://127.0.0.1:${captureServer.port}`,
-    NO_PROXY: "127.0.0.1,localhost"
-  } : {};
-  for (const name of tokenEnvNames) twinEnv[name] = token;
-  const env = {
-    POME_TASK: scenario.prompt,
-    POME_TWIN_NAMES: twins.join(","),
-    ...twinEnv,
-    POME_AUTH_TOKEN: token,
-    POME_RUN_ID: runId,
-    POME_ARTIFACTS_DIR: runDir,
-    POME_ADAPTER_SIGNALS_PATH: signalsPathForEnv,
-    ...options.extraAgentEnv ?? {},
-    ...proxyEnv
-  };
-  const captureFinalStates = async () => {
-    const finals = {};
-    for (const { twin, harness } of booted) {
-      finals[twin] = await harness.exportState();
-    }
-    if (isMultiTwin) {
-      for (const { twin } of booted) {
-        if (twin === primaryTwin) continue;
-        try {
-          await writeFile(
-            join(runDir, `state_final.${twin}.json`),
-            `${JSON.stringify(redactSecrets(finals[twin]), null, 2)}
-`
-          );
-        } catch {
-        }
-      }
-    }
-    return finals[primaryTwin];
-  };
-  try {
-    const preflight = await runAgentCommand({
-      command: options.agentCommand,
-      env,
-      // Cold agent startup can exceed 10s on CI; cap preflight below full scenario
-      // timeout but leave enough headroom for toolchain startup.
-      timeoutSeconds: Math.min(60, scenario.config.timeout),
-      preflight: true
-    });
-    if (preflight.exitCode !== 0) {
-      await recorder.flush?.();
-      const stateFinal2 = await captureFinalStates();
-      const { artifacts: artifacts2, exitCode: exitCode2 } = await writeRun({
-        artifactsDir,
-        runId,
-        scenario,
-        startedAt,
-        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        agentStdout: preflight.stdout,
-        agentStderr: preflight.stderr,
-        agentExitCode: preflight.exitCode,
-        agentTimedOut: preflight.timedOut ?? false,
-        events: recorder.events(),
-        stateInitial,
-        stateFinal: stateFinal2
-      });
-      await mergeAdapterSignalsIntoEvents(signalsPath, eventsJsonlPath);
-      void exitCode2;
-      const blockedEgress2 = await collectBlockedEgress();
-      return { scenario, runId, artifacts: artifacts2, agent: preflight, exitCode: 3, blockedEgress: blockedEgress2 };
-    }
-    const agent = await runAgentCommand({
-      command: options.agentCommand,
-      env,
-      timeoutSeconds: scenario.config.timeout
-    });
-    await recorder.flush?.();
-    const stateFinal = await captureFinalStates();
-    const { artifacts, exitCode } = await writeRun({
-      artifactsDir,
-      runId,
-      scenario,
-      startedAt,
-      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      agentStdout: agent.stdout,
-      agentStderr: agent.stderr,
-      agentExitCode: agent.exitCode,
-      agentTimedOut: agent.timedOut ?? false,
-      events: recorder.events(),
-      stateInitial,
-      stateFinal
-    });
-    await mergeAdapterSignalsIntoEvents(signalsPath, eventsJsonlPath);
-    const blockedEgress = await collectBlockedEgress();
-    return { scenario, runId, artifacts, agent, exitCode, blockedEgress };
-  } finally {
-    if (captureServer) await captureServer.shutdown();
-    await Promise.all(
-      booted.map(async ({ server, harness }) => {
-        await closeServer(server);
-        await harness.close();
-      })
-    );
-    await recorder.close?.();
-  }
-}
-function resolvePackageRoot(importMetaUrl) {
-  let dir = dirname(fileURLToPath(importMetaUrl));
-  for (let i = 0; i < 6; i++) {
-    if (existsSync(join(dir, "package.json"))) return dir;
-    const parent = resolve(dir, "..");
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return void 0;
-}
-function assetPath(...segments) {
-  const root = resolvePackageRoot(import.meta.url);
-  if (!root) {
-    throw new Error(
-      `Could not locate the @pome-sh/cli package root (no enclosing package.json) while resolving the packaged asset ${segments.join("/")}.`
-    );
-  }
-  const candidate = join(root, "assets", ...segments);
-  if (!existsSync(candidate)) {
-    throw new Error(
-      `Packaged asset not found at ${candidate}. This is a packaging bug \u2014 \`assets/\` must be listed in cli/package.json \`files\`.`
-    );
-  }
-  return candidate;
-}
-
-// src/demo/task.ts
-var DEMO_TASK_NAME = "first-run-demo";
-var DEMO_REPO = "acme/api";
-function demoTaskPath() {
-  return assetPath("demo", "first-run-demo.md");
-}
-
-export { DEMO_REPO, DEMO_TASK_NAME, assetPath, demoTaskPath, resolvePackageRoot, runTask };

package/dist/chunk-ZX4WNSZ5.js

@@ -1,71 +0,0 @@
-// src/demo/capacity.ts
-var DemoCapacityError = class extends Error {
-  constructor(kind, message) {
-    super(message);
-    this.kind = kind;
-    this.name = "DemoCapacityError";
-  }
-  kind;
-};
-function capacityKindFrom(status, detailsKind) {
-  if (typeof detailsKind === "string") {
-    switch (detailsKind) {
-      case "session_llm_call_cap":
-        return "session_llm_call_cap";
-      case "demo_ip_llm_cap":
-        return "demo_ip_llm_cap";
-      case "daily_model_cap":
-        return "daily_model_cap";
-      case "daily_judge_cap":
-        return "daily_judge_cap";
-      case "ai_gateway_disabled":
-      case "demo_model_unpriced":
-        return "gateway_unavailable";
-    }
-  }
-  if (status === 402 || status === 429) return "unknown_capacity";
-  if (status === 503) return "gateway_unavailable";
-  return null;
-}
-function capacityLabel(kind) {
-  switch (kind) {
-    case "demo_ip_mint_cap":
-    case "demo_ip_llm_cap":
-      return "the demo hit today's limit for this network \u2014 try again tomorrow, or sign up for a free account";
-    case "daily_model_cap":
-      return "the demo's daily model budget is exhausted \u2014 try again tomorrow, or sign up for a free account";
-    case "daily_judge_cap":
-      return "the demo's daily evaluation budget is exhausted \u2014 try again tomorrow, or sign up for a free account";
-    case "session_llm_call_cap":
-      return "this trial hit its model-call ceiling";
-    case "gateway_unavailable":
-      return "the demo model gateway is unavailable right now \u2014 try again shortly";
-    case "demo_mint_quota":
-    case "unknown_capacity":
-      return "the demo is at capacity today \u2014 try again tomorrow";
-  }
-}
-var CAPACITY_STDERR_PREFIX = "POME_DEMO_CAPACITY:";
-function capacityMarkerLine(kind) {
-  return `${CAPACITY_STDERR_PREFIX}${kind}`;
-}
-function parseCapacityMarker(stderr) {
-  const match = stderr.match(
-    new RegExp(`${CAPACITY_STDERR_PREFIX}([a-z_]+)`, "m")
-  );
-  if (!match) return null;
-  const kind = match[1];
-  const known = [
-    "demo_ip_mint_cap",
-    "demo_mint_quota",
-    "session_llm_call_cap",
-    "demo_ip_llm_cap",
-    "daily_model_cap",
-    "daily_judge_cap",
-    "gateway_unavailable",
-    "unknown_capacity"
-  ];
-  return known.includes(kind) ? kind : "unknown_capacity";
-}
-
-export { DemoCapacityError, capacityKindFrom, capacityLabel, capacityMarkerLine, parseCapacityMarker };