@pome-sh/cli 0.43.1 → 0.45.0

package/README.md

@@ -142,6 +142,7 @@ Global hosted configuration:
 | `POME_API_KEY` | Authenticate hosted commands. This value takes precedence over stored credentials. |
 | `POME_API_URL` | Set the control-plane URL. `--api-url` takes precedence. |
 | `POME_DASHBOARD_URL` | Set the dashboard URL for login and result links. |
+| `POME_TELEMETRY=0` | Turn off the anonymous daily usage event (one per day at most: CLI version, OS, Node major, command name; never arguments, paths or repo names). `DO_NOT_TRACK=1` is honoured too, and nothing is sent when `CI` is set. |
 
 Agent process configuration:
 
@@ -202,7 +203,6 @@ A run can also contain these files:
 
 | File | Condition |
 | --- | --- |
-| `signals.jsonl` | The runner creates this adapter-event sidecar. |
 | `egress.jsonl` | The capture proxy records refused connections here. |
 | `state_final.<twin>.json` | A multi-twin run records each additional final state. |
 | `verdict.json` | A hosted `pome run` caches the hosted verdict for `pome fix-prompt`. |

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "package": "pome-sh",
-  "version": "0.43.1",
-  "git_sha": "aa6e8ff0d76f2bfbdd8c01e72239431644cb849a",
-  "build_time": "2026-09-15T22:37:32.106Z"
+  "version": "0.45.0",
+  "git_sha": "16bd8bf4255ab4a22c0d466529abcab652301773",
+  "build_time": "2026-09-16T19:32:06.710Z"
 }

package/dist/{checks-V442KL5O.js → checks-RDU56OGI.js}

@@ -1,9 +1,10 @@
 import { getAvailablePort } from './chunk-XDU6TD4O.js';
-import { findManifestPath, readManifest } from './chunk-CS7O2ZXB.js';
+import { findManifestPath, readManifest } from './chunk-26UAPLHK.js';
+import './chunk-M7ATJ423.js';
 import { buildEgressAllowlist } from './chunk-CBFKZZBR.js';
 import './chunk-NBOQN5VX.js';
 import './chunk-YBWG5JK2.js';
-import './chunk-5KFDRR53.js';
+import './chunk-7VZBAHQ2.js';
 import './chunk-SG6ZTIMT.js';
 import './chunk-2K6BJ3PI.js';
 import './chunk-FBSA5L36.js';
@@ -182,7 +183,7 @@ async function checkTwinReachable(_configDir) {
   });
   let harness;
   try {
-    const { bootTwin } = await import('./twinHarness-33MAVAXV.js');
+    const { bootTwin } = await import('./twinHarness-I2JGKQYD.js');
     harness = await bootTwin({
       twin: "github",
       seedState: void 0,

package/dist/chunk-26UAPLHK.js

@@ -0,0 +1,191 @@
+import { manifestSchema, deriveAgentSlug, SLUG_RE } from './chunk-M7ATJ423.js';
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve, join, dirname } from 'node:path';
+import { stringify, parse } from 'yaml';
+
+// src/hosted/errors.ts
+var HostedAuthError = class extends Error {
+  constructor(message, requestId) {
+    super(message);
+    this.requestId = requestId;
+    this.name = "HostedAuthError";
+  }
+  requestId;
+};
+var HostedQuotaError = class extends Error {
+  /** `details` mirrors the cloud error envelope's machine-readable details
+   *  (e.g. `{ kind: "daily_judge_cap" }`) so `pome demo` can
+   *  render honest labeled at-capacity states. Optional: older responses and
+   *  the twin-pod 401 shape carry none. */
+  constructor(message, requestId, details) {
+    super(message);
+    this.requestId = requestId;
+    this.details = details;
+    this.name = "HostedQuotaError";
+  }
+  requestId;
+  details;
+};
+var HostedOrchError = class extends Error {
+  /** `status` is the HTTP status that produced this error, when one exists
+   *  (network/parse failures leave it undefined). `pome eval` uses it to
+   *  scope its reaped-session retry to 404/410 only. */
+  constructor(message, requestId, status, type) {
+    super(message);
+    this.requestId = requestId;
+    this.status = status;
+    this.type = type;
+    this.name = "HostedOrchError";
+  }
+  requestId;
+  status;
+  type;
+};
+var HostedUsageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HostedUsageError";
+  }
+};
+var HostedTrialError = class extends Error {
+  constructor(message, errorCode) {
+    super(message);
+    this.errorCode = errorCode;
+    this.name = "HostedTrialError";
+  }
+  errorCode;
+};
+var HostedDiscardRefusedError = class extends Error {
+  constructor(message, sessionId, state, taskName, openSeconds, discardToken) {
+    super(message);
+    this.sessionId = sessionId;
+    this.state = state;
+    this.taskName = taskName;
+    this.openSeconds = openSeconds;
+    this.discardToken = discardToken;
+    this.name = "HostedDiscardRefusedError";
+  }
+  sessionId;
+  state;
+  taskName;
+  openSeconds;
+  discardToken;
+};
+function exitCodeFor(err) {
+  if (err instanceof HostedAuthError) return 3;
+  if (err instanceof HostedQuotaError) return 4;
+  if (err instanceof HostedUsageError) return 5;
+  if (err instanceof HostedDiscardRefusedError) return 5;
+  return 2;
+}
+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 { HostedAuthError, HostedDiscardRefusedError, HostedOrchError, HostedQuotaError, HostedTrialError, HostedUsageError, MANIFEST_JSON, exitCodeFor, findManifestPath, normalizeManifestTwins, readManifest, readRequiredManifest, writeManifest };

package/dist/chunk-4LQ4IJOC.js

@@ -0,0 +1 @@
+

package/dist/{chunk-5KFDRR53.js → chunk-7VZBAHQ2.js}

@@ -104,7 +104,7 @@ function normalizeHookCausingToolUseId(event) {
     parent_event_id: null
   };
 }
-recorderEventObjectSchema.transform(normalizeTaskStepVocab);
+var recorderEventSchema = recorderEventObjectSchema.transform(normalizeTaskStepVocab);
 var eventBaseShape = {
   ts: z.string().datetime(),
   event_id: z.string().min(1),
@@ -434,4 +434,4 @@ z.object({
 });
 z.union([eventSchema, otelSpanEventSchema]);
 
-export { eventSchema, isLegacyEventRow, twinIdSchema };
+export { eventSchema, isLegacyEventRow, recorderEventSchema, twinIdSchema };

package/dist/chunk-AGZOWSLG.js

@@ -0,0 +1,142 @@
+import { mkdir, writeFile, rename, chmod, readFile, unlink, open, stat } from 'node:fs/promises';
+import { dirname, join, basename } from 'node:path';
+
+// src/twin/twinStatusFile.ts
+var STANDALONE_STATUS_PATH = ".pome/twin-status.json";
+async function writeStandaloneStatusFile(status, path = STANDALONE_STATUS_PATH) {
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(tmp, JSON.stringify(status, null, 2), { mode: 384 });
+  await rename(tmp, path);
+  await chmod(path, 384);
+}
+async function ensureSelfIgnoring(dir) {
+  if (basename(dir) !== ".pome") return;
+  const path = join(dir, ".gitignore");
+  try {
+    await writeFile(path, "*\n", { flag: "wx", mode: 384 });
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+  }
+}
+var STALE_LOCK_MS = 1e4;
+async function withStatusLock(path, fn) {
+  const lockPath = `${path}.lock`;
+  const deadline = Date.now() + 5e3;
+  for (; ; ) {
+    try {
+      const handle = await open(lockPath, "wx", 384);
+      try {
+        await handle.writeFile(String(process.pid));
+      } finally {
+        await handle.close();
+      }
+      break;
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+      const age = await stat(lockPath).then((s) => Date.now() - s.mtimeMs, () => 0);
+      if (age > STALE_LOCK_MS) {
+        await unlink(lockPath).catch(() => void 0);
+        continue;
+      }
+      if (Date.now() > deadline) {
+        throw new Error(
+          `pome twin start: ${lockPath} is held by another pome process \u2014 if none is running, delete it.`
+        );
+      }
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+  }
+  try {
+    return await fn();
+  } finally {
+    await unlink(lockPath).catch(() => void 0);
+  }
+}
+async function updateStandaloneStatusFile(entries, path = STANDALONE_STATUS_PATH) {
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  await ensureSelfIgnoring(dirname(path));
+  return await withStatusLock(path, async () => {
+    const merged = mergeStandaloneStatus(await readStandaloneStatusFile(path), entries);
+    await writeStandaloneStatusFile(merged, path);
+    return merged;
+  });
+}
+function isStatusEntry(value) {
+  if (value === null || typeof value !== "object") return false;
+  const entry = value;
+  return typeof entry.name === "string" && typeof entry.url === "string" && typeof entry.rest_url === "string" && typeof entry.mcp_url === "string" && typeof entry.auth_token === "string";
+}
+function standaloneStatusEntries(contents) {
+  if (contents === null || typeof contents !== "object") return [];
+  const file = contents;
+  if (file.twins !== null && typeof file.twins === "object") {
+    return Object.values(file.twins).filter(isStatusEntry);
+  }
+  return isStatusEntry(file) ? [pick(file)] : [];
+}
+function pick(entry) {
+  return {
+    name: entry.name,
+    url: entry.url,
+    rest_url: entry.rest_url,
+    mcp_url: entry.mcp_url,
+    auth_token: entry.auth_token
+  };
+}
+function mergeStandaloneStatus(existing, entries) {
+  const twins = {};
+  for (const entry of standaloneStatusEntries(existing)) twins[entry.name] = pick(entry);
+  for (const entry of entries) twins[entry.name] = pick(entry);
+  const first = entries[0];
+  if (first === void 0) throw new Error("mergeStandaloneStatus: no entries to write");
+  return { ...pick(first), twins };
+}
+async function readStandaloneStatusFile(path = STANDALONE_STATUS_PATH) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+var STANDALONE_STATE_DIR = ".pome/twin-state";
+function standaloneInitialStatePath(name, dir = STANDALONE_STATE_DIR) {
+  return join(dir, `${name}.initial.json`);
+}
+async function writeStandaloneInitialState(name, state, dir = STANDALONE_STATE_DIR) {
+  const path = standaloneInitialStatePath(name, dir);
+  await mkdir(dir, { recursive: true, mode: 448 });
+  const tmp = `${path}.${process.pid}.tmp`;
+  await writeFile(tmp, JSON.stringify(state), { mode: 384 });
+  await rename(tmp, path);
+  await chmod(path, 384);
+}
+async function readStandaloneInitialState(name, dir = STANDALONE_STATE_DIR) {
+  const path = standaloneInitialStatePath(name, dir);
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return void 0;
+    throw err;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error(`pome twin tape: ${path} is not valid JSON \u2014 restart the twin to rewrite it.`);
+  }
+}
+async function snapshotStandaloneInitialState(name, exportState, dir = STANDALONE_STATE_DIR) {
+  await unlink(standaloneInitialStatePath(name, dir)).catch((err) => {
+    if (err.code !== "ENOENT") throw err;
+  });
+  try {
+    await writeStandaloneInitialState(name, await exportState(), dir);
+  } catch (err) {
+    console.error(
+      `pome twin start: could not snapshot the ${name} twin's state for \`pome twin tape --diff\`: ${err.message}`
+    );
+  }
+}
+
+export { STANDALONE_STATUS_PATH, mergeStandaloneStatus, readStandaloneInitialState, readStandaloneStatusFile, snapshotStandaloneInitialState, standaloneInitialStatePath, standaloneStatusEntries, updateStandaloneStatusFile, writeStandaloneStatusFile };

package/dist/{chunk-4DXTT3RV.js → chunk-BXYPNEJY.js}

@@ -39,7 +39,7 @@ var TWIN_REGISTRY = {
         defaultSeedState,
         GitHubDomain,
         openGitHubCloneDatabase
-      } = await import('./src-G6CMFUR6.js');
+      } = await import('./src-46YGR2WY.js');
       const db = openGitHubCloneDatabase();
       const domain = new GitHubDomain(db);
       domain.seed(seedState === void 0 ? defaultSeedState() : seedState);
@@ -63,7 +63,7 @@ var TWIN_REGISTRY = {
     parseSeed: async (input) => (await import('./seed-SYJXLGWF.js')).parseSeed(input),
     seedFields: async () => Object.keys((await import('./seed-SYJXLGWF.js')).seedSchema.shape),
     async boot({ seedState, runId, recorder }) {
-      const { createSlackTwinApp, openSlackTwinDatabase, SlackDomain } = await import('./src-SJDGRXC5.js');
+      const { createSlackTwinApp, openSlackTwinDatabase, SlackDomain } = await import('./src-LPTWNBO5.js');
       const db = openSlackTwinDatabase(":memory:");
       const domain = new SlackDomain(db);
       domain.applySeed(seedState);
@@ -90,8 +90,8 @@ var TWIN_REGISTRY = {
     parseSeed: async (input) => (await import('./seed-E6SA4NKZ.js')).parseSeed(input),
     seedFields: async () => Object.keys((await import('./seed-E6SA4NKZ.js')).seedSchema.shape),
     async boot({ seedState, runId, recorder, twinBaseUrl }) {
-      const stripeTwin = await import('./src-VBXONWR3.js');
-      const { createApp } = await import('./server-2WHSHTUD.js');
+      const stripeTwin = await import('./src-STAXYPD3.js');
+      const { createApp } = await import('./server-GECKG2H6.js');
       const {
         applySeed: applyStripeSeed,
         createTwinStripeApp,
@@ -136,7 +136,7 @@ var TWIN_REGISTRY = {
     parseSeed: async (input) => (await import('./seed-W3R53GHH.js')).parseSeed(input),
     seedFields: async () => Object.keys((await import('./seed-W3R53GHH.js')).gmailSeedSchema.shape),
     async boot({ seedState, runId, recorder }) {
-      const { createGmailTwinApp, GmailDomain, openGmailTwinDatabase, parseSeed } = await import('./src-DBOHIQNB.js');
+      const { createGmailTwinApp, GmailDomain, openGmailTwinDatabase, parseSeed } = await import('./src-CV7QDV5E.js');
       const db = openGmailTwinDatabase(":memory:");
       const seed = parseSeed(seedState);
       const domain = new GmailDomain(db);
@@ -165,7 +165,7 @@ var TWIN_REGISTRY = {
         LinearDomain,
         openLinearTwinDatabase,
         parseSeed
-      } = await import('./src-FRPUTB2H.js');
+      } = await import('./src-D3PKLT54.js');
       const db = openLinearTwinDatabase(":memory:");
       const seed = parseSeed(seedState);
       const domain = new LinearDomain(db);
@@ -181,7 +181,7 @@ var TWIN_REGISTRY = {
   }
 };
 async function createGitHubSmokeApp() {
-  const { createGitHubCloneApp } = await import('./src-G6CMFUR6.js');
+  const { createGitHubCloneApp } = await import('./src-46YGR2WY.js');
   return createGitHubCloneApp();
 }
 function defaultPortFor(twin, env = process.env) {

package/dist/{chunk-GQSNU3YP.js → chunk-DX2KCFJM.js}

@@ -1,4 +1,4 @@
-import { isTwinName, TWIN_REGISTRY, TWIN_NAMES } from './chunk-4DXTT3RV.js';
+import { isTwinName, TWIN_REGISTRY, TWIN_NAMES } from './chunk-BXYPNEJY.js';
 import { readFileSync } from 'node:fs';
 import { parse } from 'yaml';
 

package/dist/{chunk-64AWQJ7R.js → chunk-EZYVICDB.js}

@@ -1,4 +1,4 @@
-import { TWIN_NAMES, isTwinName, TWIN_REGISTRY } from './chunk-4DXTT3RV.js';
+import { TWIN_NAMES, isTwinName, TWIN_REGISTRY } from './chunk-BXYPNEJY.js';
 import { createFileBackedRecorderStore, createRecorderStore } from './chunk-TWURH7YM.js';
 
 // src/recorder/recorder.ts

package/dist/{chunk-A6AM6KS4.js → chunk-HEEFOMSZ.js}

@@ -1,20 +1,21 @@
-import { readSeedFileText, parseSeedFileText, soleTwinOf, twinsNamedBy, seedsForTwins } from './chunk-GQSNU3YP.js';
+import { HostedDiscardRefusedError, HostedOrchError, HostedAuthError, readManifest, normalizeManifestTwins, HostedQuotaError, HostedTrialError } from './chunk-26UAPLHK.js';
+import { criterionSchema, normalizeTaskConfigKeys, finalizeResponseSchema, MOUNTED_TWINS, submitResultResponseSchema, createEvalSessionResponseSchema, createSessionResponseSchema, agentResponseSchema, isMultiTwinSeedEnvelope, sessionPublicSchema } from './chunk-M7ATJ423.js';
 import { gmailSeedSchema, defaultSeedState } from './chunk-PASFBRK4.js';
 import { linearSeedSchema, defaultSeedState as defaultSeedState$1 } from './chunk-3FZY376K.js';
-import { isTwinName, TWIN_REGISTRY } from './chunk-4DXTT3RV.js';
-import { criterionSchema, normalizeTaskConfigKeys, finalizeResponseSchema, MOUNTED_TWINS, HostedDiscardRefusedError, HostedOrchError, HostedAuthError, readManifest, normalizeManifestTwins, HostedQuotaError, HostedTrialError, submitResultResponseSchema, createEvalSessionResponseSchema, createSessionResponseSchema, agentResponseSchema, isMultiTwinSeedEnvelope, sessionPublicSchema } from './chunk-CS7O2ZXB.js';
+import { readSeedFileText, parseSeedFileText, soleTwinOf, twinsNamedBy, seedsForTwins } from './chunk-DX2KCFJM.js';
+import { isTwinName, TWIN_REGISTRY } from './chunk-BXYPNEJY.js';
 import { seedSchema as seedSchema$1, parseSeed, defaultSeedState as defaultSeedState$2 } from './chunk-NBOQN5VX.js';
 import { seedSchema } from './chunk-YBWG5JK2.js';
 import { toTwinHttpEventRow } from './chunk-TWURH7YM.js';
 import { redactEvent, redactSecrets } from './chunk-SG6ZTIMT.js';
 import { seedSchema as seedSchema$2 } from './chunk-2K6BJ3PI.js';
-import { mkdir, appendFile, writeFile, readFile, rm, stat, chmod, mkdtemp, readdir, rename } from 'node:fs/promises';
+import { mkdir, appendFile, writeFile, readFile, rm, stat, chmod, readdir, rename } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { join, basename, extname, dirname } from 'node:path';
 import { parse } from 'yaml';
 import { z } from 'zod';
 import { randomUUID, createHash } from 'node:crypto';
-import { tmpdir, homedir } from 'node:os';
+import { homedir } from 'node:os';
 import { execFile, spawn } from 'node:child_process';
 import { promisify } from 'node:util';
 import { createInterface } from 'node:readline';
@@ -1192,20 +1193,6 @@ function createHostedClient(config) {
         }
       );
     },
-    async requestSignalsUploadUrl(sessionId) {
-      return postJson(
-        `/v1/sessions/${encodeURIComponent(sessionId)}/signals-upload-url`,
-        {},
-        (raw) => {
-          if (typeof raw === "object" && raw !== null && typeof raw.url === "string" && typeof raw.key === "string") {
-            return raw;
-          }
-          throw new HostedOrchError(
-            "POST /v1/sessions/:id/signals-upload-url returned unexpected shape"
-          );
-        }
-      );
-    },
     async requestMetaUploadUrl(sessionId) {
       return postJson(
         `/v1/sessions/${encodeURIComponent(sessionId)}/meta-upload-url`,
@@ -1265,9 +1252,6 @@ function createHostedClient(config) {
       if (input.stateFinalStorageKey !== void 0) {
         body.state_final_storage_key = input.stateFinalStorageKey;
       }
-      if (input.signalsStorageKey !== void 0) {
-        body.signals_storage_key = input.signalsStorageKey;
-      }
       if (input.perTwinStateKeys !== void 0 && Object.keys(input.perTwinStateKeys).length > 0) {
         body.per_twin_state_keys = input.perTwinStateKeys;
       }
@@ -2349,26 +2333,6 @@ async function uploadRunBlobs(client, sessionId, blobs) {
       return null;
     }
   }
-  async function uploadSignals() {
-    try {
-      if (blobs.signalsJsonl.trim().length === 0) {
-        return null;
-      }
-      const upload = await client.requestSignalsUploadUrl(sessionId);
-      const ok = await putBlob(
-        upload.url,
-        blobs.signalsJsonl,
-        "application/x-ndjson",
-        "signals.jsonl"
-      );
-      return ok ? upload.key : null;
-    } catch (err) {
-      console.warn(
-        `[pome] signals.jsonl upload skipped (${err instanceof Error ? err.message : String(err)}); continuing with signals_storage_key=null`
-      );
-      return null;
-    }
-  }
   async function uploadStates() {
     const multiTwin = (blobs.twins?.length ?? 0) > 1;
     try {
@@ -2449,10 +2413,9 @@ async function uploadRunBlobs(client, sessionId, blobs) {
       return null;
     }
   }
-  const [eventsKey, stateKeys, signalsKey, metaKey] = await Promise.all([
+  const [eventsKey, stateKeys, metaKey] = await Promise.all([
     uploadEvents(),
     uploadStates(),
-    uploadSignals(),
     uploadMeta()
   ]);
   return {
@@ -2460,8 +2423,7 @@ async function uploadRunBlobs(client, sessionId, blobs) {
     stateInitialKey: stateKeys.initialKey,
     stateFinalKey: stateKeys.finalKey,
     perTwinStateKeys: stateKeys.perTwinStateKeys,
-    metaKey,
-    signalsKey
+    metaKey
   };
 }
 function scoreFromFinalizeResponse(finalized) {
@@ -2525,8 +2487,7 @@ function buildAgentEnv2(params) {
     agentId,
     runId,
     artifactsDir,
-    slug,
-    signalsPath
+    slug
   } = params;
   const env = {
     POME_TASK: prompt,
@@ -2559,8 +2520,7 @@ function buildAgentEnv2(params) {
     POME_STRIPE_API_KEY: session.agent_token,
     POME_AUTH_TOKEN: session.agent_token,
     POME_RUN_ID: runId,
-    POME_ARTIFACTS_DIR: join(artifactsDir, slug, runId),
-    POME_ADAPTER_SIGNALS_PATH: signalsPath
+    POME_ARTIFACTS_DIR: join(artifactsDir, slug, runId)
   };
   for (const twin of twins) {
     const upper = twin.toUpperCase();
@@ -2597,9 +2557,6 @@ async function runTaskHosted(options) {
   const agentId = identity.agentId;
   const agentVersion = identity.agentVersion;
   const agentSdk = identity.framework ?? null;
-  const signalsDir = await mkdtemp(join(tmpdir(), "pome-signals-"));
-  const signalsPath = join(signalsDir, `${randomUUID()}.jsonl`);
-  await writeFile(signalsPath, "");
   const session = await createSessionOrExplain(
     client,
     options.premintedSession,
@@ -2638,8 +2595,7 @@ async function runTaskHosted(options) {
       agentId,
       runId,
       artifactsDir,
-      slug: scenario.slug,
-      signalsPath
+      slug: scenario.slug
     });
     const preflightTimeoutSeconds = Math.min(10, scenario.config.timeout);
     const preflight = await runAgentCommand({
@@ -2650,7 +2606,6 @@ async function runTaskHosted(options) {
     });
     let agentResult = preflight;
     if (preflight.exitCode === 0) {
-      await writeFile(signalsPath, "");
       agentResult = await runAgentCommand({
         command: options.agentCommand,
         env,
@@ -2729,16 +2684,6 @@ async function runTaskHosted(options) {
     const eventsJsonl = legacyEvents.map((e) => JSON.stringify(redactEvent(toTwinHttpEvent(e)))).join("\n") + "\n";
     const stateInitialJson = JSON.stringify(redactSecrets(stateInitial));
     const stateFinalJson = JSON.stringify(redactSecrets(stateFinal));
-    let signalsJsonl = "";
-    try {
-      signalsJsonl = redactJsonl(
-        await readFile(signalsPath, "utf8").catch(() => "")
-      );
-    } catch (err) {
-      console.warn(
-        `[pome] signals.jsonl upload skipped (${err instanceof Error ? err.message : String(err)}); continuing with signals_storage_key=null`
-      );
-    }
     const metaJson = await readFile(join(artifacts.runDir, "meta.json"), "utf8").catch(
       () => "{}"
     );
@@ -2755,7 +2700,6 @@ async function runTaskHosted(options) {
       eventsJsonl,
       stateInitialJson,
       stateFinalJson,
-      signalsJsonl,
       metaJson,
       twins: isMultiTwin ? twins : void 0,
       perTwinState
@@ -2765,7 +2709,6 @@ async function runTaskHosted(options) {
       initialKey: uploaded.stateInitialKey,
       finalKey: uploaded.stateFinalKey
     };
-    const signalsKey = uploaded.signalsKey;
     const criteriaDefs = scenario.criteria.map((c, idx) => ({
       id: `crit_${idx}`,
       text: c.text,
@@ -2794,7 +2737,6 @@ async function runTaskHosted(options) {
       traceStorageKey: eventsJsonlUrl ?? void 0,
       stateInitialStorageKey: stateKeys.initialKey ?? void 0,
       stateFinalStorageKey: stateKeys.finalKey ?? void 0,
-      signalsStorageKey: signalsKey ?? void 0,
       // Multi-twin (M3): per-twin state storage keys (>=1 key per entry).
       // Undefined for single-twin / an older cloud that returned no per_twin
       // upload block — the cloud then scores the primary twin from the flat keys.
@@ -2850,7 +2792,6 @@ async function runTaskHosted(options) {
     throw err;
   } finally {
     await client.deleteSession(session.session_id, true, { discard: true }).catch(() => void 0);
-    await rm(signalsDir, { recursive: true, force: true }).catch(() => void 0);
   }
 }
 async function createSessionOrExplain(client, preminted, input) {