@pome-sh/cli 0.20.0 → 0.21.1

package/dist/chunk-XDU6TD4O.js

@@ -0,0 +1,20 @@
+import { createServer } from 'node:net';
+
+// src/runner/ports.ts
+async function getAvailablePort() {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.on("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (typeof address === "object" && address) {
+        const { port } = address;
+        server.close(() => resolve(port));
+      } else {
+        server.close(() => reject(new Error("Could not allocate a local port")));
+      }
+    });
+  });
+}
+
+export { getAvailablePort };

package/dist/chunk-ZX4WNSZ5.js

@@ -0,0 +1,71 @@
+// 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 };

package/dist/egress-4V6DVJZ7.js

@@ -0,0 +1 @@
+export { DEFAULT_LLM_PROVIDER_HOSTS, buildEgressAllowlist, isHostAllowed, parseAllowCsv, readBlockedEgress } from './chunk-CBFKZZBR.js';

package/dist/install-4OATBKG3.js

@@ -0,0 +1,22 @@
+// src/cli/install.ts
+var GEN2_REDIRECT = [
+  "pome install (Gen-1 agent-driven wiring) is retired.",
+  "",
+  "Wire your own agent to pome the Gen-2 way:",
+  "  1. claude mcp add --transport http pome https://mcp.pome.sh/mcp",
+  "                                           # connect the pome control MCP",
+  "  2. npx skills add pome-sh/digital-twins --skill '*'",
+  "                                           # install the Gen-2 coach skills",
+  "                                           # (--skill '*' takes all six; the",
+  "                                           #  picker opens with none ticked)",
+  "  3. run the pome-intake skill to register the examinee and check twin",
+  "     coverage (self-hosted REST agent: use the coach's REST-launch preflight).",
+  "",
+  "Already have pome.json? `pome register agent <name>` and `pome doctor` still apply.",
+  "See `pome docs getting-started`."
+];
+function runInstall() {
+  for (const line of GEN2_REDIRECT) console.error(line);
+}
+
+export { runInstall };

package/dist/render-ZQQ4UMNO.js

@@ -0,0 +1,40 @@
+// src/doctor/render.ts
+var CAUSE_COLUMN = "cause  ";
+var FIX_COLUMN = "fix    ";
+var CONTINUATION = " ".repeat(FIX_COLUMN.length);
+function renderDoctorReport(report, options = {}) {
+  const lines = [options.header ?? "checking your wiring \u2026"];
+  for (const check of report.checks) {
+    const glyph = check.status === "pass" ? "\u2713" : "\u2717";
+    const detail = check.detail ? `  ${check.detail}` : "";
+    lines.push(`${glyph} ${check.label}${detail}`);
+  }
+  const failed = report.checks.find((c) => c.status === "fail");
+  if (failed) {
+    lines.push("");
+    if (failed.cause) lines.push(`${CAUSE_COLUMN}${failed.cause}`);
+    if (failed.fix) {
+      const [first, ...rest] = failed.fix.split("\n");
+      lines.push(`${FIX_COLUMN}${first ?? ""}`);
+      for (const line of rest) lines.push(`${CONTINUATION}${line}`);
+    }
+    lines.push("");
+    lines.push("until this passes, your agent would hit production.");
+    lines.push("pome will not run trials against a live API.");
+  } else if (options.passNote) {
+    lines.push("");
+    lines.push(
+      "note: a green check means the wiring is right, not that your agent runs"
+    );
+    lines.push(
+      "cleanly \u2014 pome doctor never launches it, and a run's preflight probe exits"
+    );
+    lines.push(
+      "it early (POME_PREFLIGHT=1), so a bug on the code path they skip surfaces"
+    );
+    lines.push("only on a full trial run.");
+  }
+  return lines;
+}
+
+export { renderDoctorReport };

package/dist/run-CFA4LZWQ.js

@@ -0,0 +1,203 @@
+import { isHostAllowed } from './chunk-CBFKZZBR.js';
+import './chunk-NW7HGA2K.js';
+import { redactEvent } from './chunk-SG6ZTIMT.js';
+import { resolve, dirname } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { createWriteStream } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { createServer } from 'node:http';
+import { connect } from 'node:net';
+
+async function runCaptureServer(options) {
+  await mkdir(dirname(options.eventsOut), { recursive: true });
+  const writer = createWriteStream(options.eventsOut, { flags: "a" });
+  const allowHosts = options.allowHosts ?? [];
+  let egressWriter = null;
+  if (options.egressOut) {
+    await mkdir(dirname(options.egressOut), { recursive: true });
+    egressWriter = createWriteStream(options.egressOut, { flags: "a" });
+  }
+  const pendingWrites = /* @__PURE__ */ new Set();
+  const liveSockets = /* @__PURE__ */ new Set();
+  let shuttingDown = false;
+  const server = createServer((_req, res) => {
+    res.writeHead(405, { "content-type": "text/plain", connection: "close" });
+    res.end("pome capture-server accepts CONNECT only\n");
+  });
+  server.on("connect", (req, clientSocket, head) => {
+    handleConnect({ req, clientSocket, head, writer, egressWriter, allowHosts, liveSockets, pendingWrites });
+  });
+  await new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(options.port, "127.0.0.1", () => resolve2());
+  });
+  const addr = server.address();
+  const port = typeof addr === "object" && addr !== null ? addr.port : options.port;
+  const flush = async () => {
+    while (pendingWrites.size > 0) {
+      await Promise.all([...pendingWrites]);
+    }
+  };
+  const close = async () => {
+    if (shuttingDown) {
+      await flush();
+      return;
+    }
+    shuttingDown = true;
+    const serverClosed = new Promise((resolve2) => server.close(() => resolve2()));
+    for (const sock of liveSockets) sock.destroy();
+    await serverClosed;
+    await flush();
+    await new Promise((resolve2) => writer.end(() => resolve2()));
+    if (egressWriter) {
+      const ew = egressWriter;
+      await new Promise((resolve2) => ew.end(() => resolve2()));
+    }
+  };
+  return { port, flush, close };
+}
+function handleConnect({
+  req,
+  clientSocket,
+  head,
+  writer,
+  egressWriter,
+  allowHosts,
+  liveSockets,
+  pendingWrites
+}) {
+  const target = parseConnectTarget(req.url ?? "");
+  if (!target) {
+    clientSocket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+    return;
+  }
+  const { host, port } = target;
+  if (!isHostAllowed(host, allowHosts)) {
+    if (egressWriter) {
+      const row = {
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        kind: "EgressRefusedEvent",
+        host,
+        port
+      };
+      const ew = egressWriter;
+      const write = new Promise((resolve2) => {
+        ew.write(JSON.stringify(row) + "\n", () => resolve2());
+      });
+      pendingWrites.add(write);
+      void write.finally(() => pendingWrites.delete(write));
+    }
+    clientSocket.end(
+      `HTTP/1.1 403 Forbidden\r
+content-type: text/plain\r
+connection: close\r
+\r
+pome egress floor: CONNECT to ${host}:${port} refused \u2014 not on the allowlist (twin hosts + LLM providers + localhost). Extend with POME_EGRESS_ALLOW=<host,...> if this host is intentional.\r
+`
+    );
+    return;
+  }
+  clientSocket.pause();
+  const start = Date.now();
+  let bytesOut = head.length;
+  let bytesIn = 0;
+  let finalized = false;
+  const upstream = connect({ host, port });
+  liveSockets.add(clientSocket);
+  liveSockets.add(upstream);
+  const finalize = () => {
+    if (finalized) return;
+    finalized = true;
+    liveSockets.delete(clientSocket);
+    liveSockets.delete(upstream);
+    if (!clientSocket.destroyed) clientSocket.destroy();
+    if (!upstream.destroyed) upstream.destroy();
+    const row = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      event_id: randomUUID(),
+      parent_event_id: null,
+      kind: "LlmCallEvent",
+      host,
+      port,
+      latency_ms: Date.now() - start,
+      bytes_in: bytesIn,
+      bytes_out: bytesOut,
+      url: null,
+      method: null,
+      status: null,
+      model: null,
+      prompt_tokens: null,
+      completion_tokens: null,
+      cost_usd: null
+    };
+    const redacted = redactEvent(row);
+    const write = new Promise((resolve2) => {
+      writer.write(JSON.stringify(redacted) + "\n", () => resolve2());
+    });
+    pendingWrites.add(write);
+    void write.finally(() => pendingWrites.delete(write));
+  };
+  upstream.once("connect", () => {
+    clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+    if (head.length > 0) upstream.write(head);
+    clientSocket.on("data", (chunk) => {
+      bytesOut += chunk.length;
+    });
+    upstream.on("data", (chunk) => {
+      bytesIn += chunk.length;
+    });
+    clientSocket.pipe(upstream);
+    upstream.pipe(clientSocket);
+    clientSocket.resume();
+  });
+  upstream.once("error", () => {
+    if (!clientSocket.destroyed) {
+      try {
+        clientSocket.end("HTTP/1.1 502 Bad Gateway\r\n\r\n");
+      } catch {
+      }
+    }
+    finalize();
+  });
+  clientSocket.once("error", finalize);
+  clientSocket.once("close", finalize);
+  upstream.once("close", finalize);
+}
+function parseConnectTarget(spec) {
+  if (spec.length === 0) return null;
+  const lastColon = spec.lastIndexOf(":");
+  if (lastColon === -1) return null;
+  let host = spec.slice(0, lastColon);
+  const port = Number(spec.slice(lastColon + 1));
+  if (!Number.isInteger(port) || port < 1 || port > 65535) return null;
+  if (host.startsWith("[") && host.endsWith("]")) host = host.slice(1, -1);
+  if (host.length === 0) return null;
+  return { host, port };
+}
+
+// src/capture-server/run.ts
+async function runCaptureServerCommand(options) {
+  const eventsOut = resolve(options.eventsOut);
+  const egressOut = options.egressOut ? resolve(options.egressOut) : void 0;
+  const allowHosts = options.allowHosts ?? [];
+  const handle = await runCaptureServer({ port: options.port, eventsOut, allowHosts, egressOut });
+  console.error(
+    `pome capture-server listening on 127.0.0.1:${handle.port} (events \u2192 ${eventsOut})`
+  );
+  console.error(
+    `pome capture-server egress floor: deny-by-default (${allowHosts.length} allowlisted pattern(s) + loopback)`
+  );
+  let shuttingDown = false;
+  const shutdown = async (signal) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    console.error(`pome capture-server: received ${signal}, draining\u2026`);
+    await handle.close();
+    console.error("pome capture-server: stopped");
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => void shutdown("SIGTERM"));
+  process.on("SIGINT", () => void shutdown("SIGINT"));
+}
+
+export { runCaptureServerCommand };

package/dist/runDemo-VWKBJRSL.js

@@ -0,0 +1,327 @@
+import { newGroupId, reassuranceBox, twinReadyLine, trialsHeaderLine, trialLine, summaryLines, evaluatingLine, criterionPhrase } from './chunk-RGZBC7NF.js';
+import { DemoCapacityError, capacityLabel, parseCapacityMarker, capacityKindFrom } from './chunk-ZX4WNSZ5.js';
+import { runTask, demoTaskPath, DEMO_TASK_NAME, DEMO_REPO } from './chunk-W5EJAOWD.js';
+import { getAvailablePort } from './chunk-XDU6TD4O.js';
+import './chunk-CBFKZZBR.js';
+import { createHostedClient, parseTaskFile, uploadRunBlobs, scoreFromFinalizeResponse, scoreStatus, outcomeOf } from './chunk-D3GRORLQ.js';
+import './chunk-NW7HGA2K.js';
+import { HostedQuotaError, HostedOrchError } from './chunk-2Q7AYEUA.js';
+import './chunk-OKDJRKJV.js';
+import './chunk-WVWV7DLA.js';
+import './chunk-APAS34RJ.js';
+import './chunk-NY55QTVQ.js';
+import { bootTwin } from './chunk-GEAGPLZZ.js';
+import './chunk-OHKJGCWS.js';
+import './chunk-LZIPGCQJ.js';
+import './chunk-VBATFCWR.js';
+import './chunk-SG6ZTIMT.js';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+
+var demoSessionSchema = z.object({
+  session_id: z.string().min(1),
+  demo_token: z.string().min(1),
+  expires_at: z.string()
+});
+async function mintDemoSessions(options) {
+  const sessions = [];
+  for (let i = 0; i < options.count; i += 1) {
+    sessions.push(await mintOne(options));
+  }
+  return sessions;
+}
+async function mintOne(options) {
+  const doFetch = options.fetchImpl ?? fetch;
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), options.timeoutMs ?? 3e4);
+  let res;
+  try {
+    res = await doFetch(`${options.apiBase}/v1/demo/sessions`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        task_name: options.taskName,
+        task_hash: "",
+        group_id: options.groupId
+      }),
+      signal: ctrl.signal
+    });
+  } catch (err) {
+    throw new HostedOrchError(
+      err instanceof Error ? err.message : "network error"
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+  const text = await res.text();
+  let json = {};
+  try {
+    json = text.length ? JSON.parse(text) : {};
+  } catch {
+    throw new HostedOrchError(
+      `POST /v1/demo/sessions returned non-JSON (status ${res.status})`
+    );
+  }
+  if (!res.ok) {
+    const envelope = json.error;
+    let kind = capacityKindFrom(res.status, envelope?.details?.kind);
+    if (kind === "unknown_capacity") {
+      kind = res.status === 429 ? "demo_ip_mint_cap" : "demo_mint_quota";
+    }
+    if (kind) {
+      throw new DemoCapacityError(kind, envelope?.message ?? capacityLabel(kind));
+    }
+    throw new HostedOrchError(
+      envelope?.message ?? `POST /v1/demo/sessions \u2192 HTTP ${res.status}`,
+      void 0,
+      res.status
+    );
+  }
+  const parsed = demoSessionSchema.safeParse(json);
+  if (!parsed.success) {
+    throw new HostedOrchError(
+      `POST /v1/demo/sessions returned an unexpected shape: ${parsed.error.message}`
+    );
+  }
+  return parsed.data;
+}
+
+// src/demo/runDemo.ts
+var DEMO_FINALIZE_TIMEOUT_MS = 6e4;
+async function runDemo(options) {
+  const out = options.out ?? ((line) => console.error(line));
+  const trials = options.trials ?? 5;
+  const artifactsDir = options.artifactsDir ?? "runs";
+  const runTaskFn = options.runTaskFn ?? runTask;
+  const mintFn = options.mintFn ?? mintDemoSessions;
+  const trialClientFactory = options.trialClientFactory ?? ((session) => createHostedClient({
+    baseUrl: options.apiBase,
+    apiKey: session.demo_token,
+    authScheme: "bearer",
+    timeoutMs: DEMO_FINALIZE_TIMEOUT_MS,
+    finalizeTimeoutMs: DEMO_FINALIZE_TIMEOUT_MS
+  }));
+  const groupId = newGroupId();
+  const taskPath = demoTaskPath();
+  for (const line of reassuranceBox()) out(line);
+  out("");
+  let sessions;
+  try {
+    sessions = await mintFn({
+      apiBase: options.apiBase,
+      taskName: DEMO_TASK_NAME,
+      groupId,
+      count: trials
+    });
+  } catch (err) {
+    if (err instanceof DemoCapacityError) {
+      out(capacityLabel(err.kind));
+      return { exitCode: 4, groupId, verdicts: [] };
+    }
+    out(
+      `could not reach the pome demo service (${err instanceof Error ? err.message : String(err)})`
+    );
+    return { exitCode: 2, groupId, verdicts: [] };
+  }
+  if (options.skipTwinWarmup !== true) {
+    const scenario = await parseTaskFile(taskPath);
+    const warmupStart = Date.now();
+    const port = await getAvailablePort();
+    const harness = await bootTwin({
+      twin: "github",
+      seedState: scenario.seedState,
+      runId: "demo-warmup",
+      twinBaseUrl: `http://127.0.0.1:${port}`
+    });
+    await harness.close();
+    out(twinReadyLine((Date.now() - warmupStart) / 1e3));
+  }
+  out(trialsHeaderLine(trials, DEMO_TASK_NAME));
+  const agentCommand = options.agentCommand ?? defaultDemoAgentCommand(process.execPath, process.argv[1]);
+  const verdicts = [];
+  const collectedFailures = [];
+  let capacityAbort = null;
+  for (let i = 0; i < trials; i += 1) {
+    const session = sessions[i];
+    const trialNumber = i + 1;
+    const client = trialClientFactory(session);
+    const progress = { finalized: false };
+    let verdict;
+    let abortCode = null;
+    try {
+      verdict = await runOneTrial({
+        trialNumber,
+        session,
+        taskPath,
+        agentCommand,
+        artifactsDir,
+        apiBase: options.apiBase,
+        runTaskFn,
+        client,
+        captureServerCommand: options.captureServerCommand,
+        out,
+        collectedFailures,
+        progress
+      });
+    } catch (err) {
+      if (err instanceof DemoCapacityError) {
+        abortCode = err.kind;
+        capacityAbort = capacityLabel(err.kind);
+        verdict = { kind: "errored", reason: "demo at capacity" };
+      } else if (isJudgeCapQuota(err)) {
+        abortCode = "daily_judge_cap";
+        capacityAbort = capacityLabel("daily_judge_cap");
+        verdict = { kind: "errored", reason: "demo at capacity" };
+      } else {
+        verdict = {
+          kind: "errored",
+          reason: shortReason(err instanceof Error ? err.message : String(err))
+        };
+      }
+      if (!progress.finalized) {
+        await abandonQuietly(client, session.session_id, abortCode ?? "trial_crashed");
+      }
+    }
+    verdicts.push(verdict);
+    out(trialLine(trialNumber, verdict));
+    if (capacityAbort) {
+      for (let j = i + 1; j < trials; j += 1) {
+        const orphan = sessions[j];
+        await abandonQuietly(
+          trialClientFactory(orphan),
+          orphan.session_id,
+          abortCode ?? "unknown_capacity"
+        );
+      }
+      break;
+    }
+  }
+  if (capacityAbort) out(capacityAbort);
+  const failing = mostCommonFailedCriterion(collectedFailures);
+  out("");
+  for (const line of summaryLines({
+    verdicts,
+    failingCriterionPhrase: failing?.phrase,
+    failingCriterionCount: failing?.count,
+    previewUrl: `${options.dashboardBase.replace(/\/$/, "")}/demo/${groupId}`
+  })) {
+    out(line);
+  }
+  const evaluated = verdicts.filter((v) => v.kind !== "errored").length;
+  const exitCode = evaluated > 0 ? 0 : capacityAbort ? 4 : 1;
+  return { exitCode, groupId, verdicts };
+}
+async function runOneTrial(input) {
+  const startedAt = Date.now();
+  const result = await input.runTaskFn({
+    taskPath: input.taskPath,
+    agentCommand: input.agentCommand,
+    artifactsDir: input.artifactsDir,
+    captureServerCommand: input.captureServerCommand,
+    extraAgentEnv: {
+      POME_DEMO_LLM_URL: `${input.apiBase}/v1/demo/sessions/${input.session.session_id}/llm`,
+      POME_DEMO_TOKEN: input.session.demo_token,
+      POME_DEMO_TASK_NAME: DEMO_TASK_NAME,
+      POME_DEMO_REPO: DEMO_REPO
+    },
+    egressExtraHosts: [new URL(input.apiBase).hostname]
+  });
+  const agentSeconds = (Date.now() - startedAt) / 1e3;
+  if (result.exitCode !== 0) {
+    const capacityKind = parseCapacityMarker(result.agent.stderr);
+    if (capacityKind) {
+      throw new DemoCapacityError(capacityKind, capacityLabel(capacityKind));
+    }
+    if (result.agent.timedOut) {
+      await abandonQuietly(input.client, input.session.session_id, "agent_timeout");
+      return { kind: "errored", reason: "trial timed out" };
+    }
+    await abandonQuietly(input.client, input.session.session_id, "agent_exit_nonzero");
+    return {
+      kind: "errored",
+      reason: shortReason(lastLine(result.agent.stderr) ?? "agent failed")
+    };
+  }
+  input.out(evaluatingLine(input.trialNumber));
+  const runDir = result.artifacts.runDir;
+  const [eventsJsonl, stateInitialJson, stateFinalJson, metaJson] = await Promise.all([
+    readFile(join(runDir, "events.jsonl"), "utf8"),
+    readFile(join(runDir, "state_initial.json"), "utf8"),
+    readFile(join(runDir, "state_final.json"), "utf8"),
+    // D18.1 — best-effort: a demo trial's verdict must never hinge on the
+    // meta.json sidecar being readable.
+    readFile(join(runDir, "meta.json"), "utf8").catch(() => "{}")
+  ]);
+  const uploaded = await uploadRunBlobs(input.client, input.session.session_id, {
+    eventsJsonl,
+    stateInitialJson,
+    stateFinalJson,
+    signalsJsonl: "",
+    metaJson
+  });
+  const finalized = await input.client.finalize(input.session.session_id, {
+    stopReason: "completed",
+    exitCode: 0,
+    durationMs: Math.max(0, Math.round(agentSeconds * 1e3)),
+    agentModel: "demo-gateway",
+    agentSdk: null,
+    criteria: [],
+    taskName: DEMO_TASK_NAME,
+    taskHash: "",
+    taskPrompt: "",
+    expectedBehavior: "",
+    traceStorageKey: uploaded.eventsKey ?? void 0,
+    stateInitialStorageKey: uploaded.stateInitialKey ?? void 0,
+    stateFinalStorageKey: uploaded.stateFinalKey ?? void 0
+  });
+  input.progress.finalized = true;
+  const score = scoreFromFinalizeResponse(finalized);
+  const status = scoreStatus(score, 100);
+  if (status === "pass") {
+    return { kind: "passed", seconds: agentSeconds };
+  }
+  if (status === "fail") {
+    const failedResults = score.results.filter((r) => outcomeOf(r) === "failed");
+    for (const r of failedResults) input.collectedFailures.push(r.criterion.text);
+    const note = failedResults[0] ? criterionPhrase(failedResults[0].criterion.text) : "criterion not met";
+    return { kind: "failed", seconds: agentSeconds, note };
+  }
+  return { kind: "errored", reason: "cloud could not evaluate the trace" };
+}
+async function abandonQuietly(client, sessionId, errorCode) {
+  try {
+    await client.abandonSession(sessionId, { errorCode });
+  } catch {
+  }
+}
+function isJudgeCapQuota(err) {
+  return err instanceof HostedQuotaError && capacityKindFrom(402, err.details?.kind) === "daily_judge_cap";
+}
+function mostCommonFailedCriterion(failures) {
+  if (failures.length === 0) return null;
+  const counts = /* @__PURE__ */ new Map();
+  for (const text2 of failures) {
+    counts.set(text2, (counts.get(text2) ?? 0) + 1);
+  }
+  const [text, count] = [...counts.entries()].sort((a, b) => b[1] - a[1])[0];
+  return { phrase: criterionPhrase(text), count };
+}
+function lastLine(text) {
+  const lines = text.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  return lines.length > 0 ? lines[lines.length - 1] : null;
+}
+function shortReason(reason) {
+  const flat = reason.replace(/\s+/g, " ").trim();
+  return flat.length > 72 ? `${flat.slice(0, 69)}\u2026` : flat;
+}
+function defaultDemoAgentCommand(execPath, scriptPath) {
+  if (!scriptPath || scriptPath.length === 0) {
+    throw new Error(
+      "Cannot determine the pome binary path for the demo agent (process.argv[1] is empty)."
+    );
+  }
+  return `"${execPath}" "${scriptPath}" demo-agent`;
+}
+
+export { defaultDemoAgentCommand, runDemo };