@pome-sh/cli 0.45.1 → 0.46.0

package/dist/{src-46YGR2WY.js → src-L54OSFDK.js}

@@ -1,7 +1,7 @@
 import './chunk-C4BVTUA3.js';
 import { defaultSeedState, parseSeed } from './chunk-NBOQN5VX.js';
 export { defaultSeedState, parseSeed, seedSchema } from './chunk-NBOQN5VX.js';
-import { routeInputDeclarer, integerInput, mountDeclaredRoute, UndeclaredInputError, MalformedBodyError } from './chunk-IZFM7W2V.js';
+import { routeInputDeclarer, integerInput, mountDeclaredRoute, UndeclaredInputError, MalformedBodyError } from './chunk-GBMPR32X.js';
 import { loadMcpToolFixture, defineTwin, twinBuildInfo, deriveMcpToolTable, UnknownToolError, openTwinDatabase, createApp, typeDisagreements } from './chunk-TWURH7YM.js';
 import './chunk-7VZBAHQ2.js';
 import './chunk-SG6ZTIMT.js';

package/dist/{src-LPTWNBO5.js → src-LYV6LLKW.js}

@@ -2,7 +2,7 @@ export { SLACK_CHECKS } from './chunk-2ZGVDTJC.js';
 import './chunk-JWJYNAWI.js';
 import { defaultSeedState, parseSeed } from './chunk-YBWG5JK2.js';
 export { defaultSeedState, loadSeedFromEnv, parseSeed, seedSchema } from './chunk-YBWG5JK2.js';
-import { routeInputDeclarer, booleanInput, integerInput, mountDeclaredRoute, UndeclaredInputError } from './chunk-IZFM7W2V.js';
+import { routeInputDeclarer, booleanInput, integerInput, mountDeclaredRoute, UndeclaredInputError } from './chunk-GBMPR32X.js';
 import { loadMcpToolFixture, defineTwin, queryTokenResolver, formTokenResolver, deriveMcpToolTable, UnknownToolError, openTwinDatabase, createApp, typeDisagreements } from './chunk-TWURH7YM.js';
 import './chunk-7VZBAHQ2.js';
 import './chunk-SG6ZTIMT.js';

package/dist/{src-D3PKLT54.js → src-MRJ73S46.js}

@@ -2,7 +2,7 @@ export { LINEAR_CHECKS } from './chunk-TSOSDKXP.js';
 import { MCP_PAGE_MAX, defaultSeedState, linearSeedSchema, notFound, badUserInput, MCP_PAGE_DEFAULT, DEFAULT_LINEAR_EMAIL, RELAY_PAGE_MAX, RELAY_PAGE_DEFAULT, STATE_EXPORT_CAP, parseSeed, DEFAULT_LINEAR_CLOCK, LINEAR_PROVIDER_TOKEN_PREFIX, DEFAULT_LINEAR_SID, DEFAULT_SCOPES, linearErrorEnvelope, unauthorizedEnvelope, unsupportedEnvelope, forbiddenEnvelope, assertWebhookUrl, ACCESS_TOKEN_TTL_SECONDS, OAUTH_CODE_TTL_SECONDS, TITLE_MAX_BYTES, BODY_MAX_BYTES, LinearTwinError, GRAPHQL_QUERY_MAX_BYTES, GRAPHQL_SELECTION_DEPTH_MAX } from './chunk-3FZY376K.js';
 export { DEFAULT_LINEAR_CLOCK, DEFAULT_LINEAR_EMAIL, DEFAULT_LINEAR_PORT, DEFAULT_LINEAR_SID, DEFAULT_LINEAR_TOKEN, LINEAR_PROVIDER_TOKEN_PREFIX, LinearTwinError, STATE_EXPORT_CAP, assertWebhookUrl, defaultSeedState, linearErrorEnvelope, linearSeedSchema, loadSeedFromEnv, parseSeed, unauthorizedEnvelope, unsupportedEnvelope, webhookUrlError } from './chunk-3FZY376K.js';
 import './chunk-JWJYNAWI.js';
-import { routeInputDeclarer, mountDeclaredRoute, UndeclaredInputError } from './chunk-IZFM7W2V.js';
+import { routeInputDeclarer, mountDeclaredRoute, UndeclaredInputError } from './chunk-GBMPR32X.js';
 import { loadMcpToolFixture, deriveMcpToolTable, openTwinDatabase, defineTwin, createApp } from './chunk-TWURH7YM.js';
 import './chunk-7VZBAHQ2.js';
 import './chunk-SG6ZTIMT.js';

package/dist/{src-CV7QDV5E.js → src-PQ35TNOF.js}

@@ -2,7 +2,7 @@ export { GMAIL_CHECKS } from './chunk-JM6VS62R.js';
 import { gmailErrorEnvelope, gmailSeedSchema, parseSeed, defaultSeedState, notFound, invalidArgument, checkFault, unsupported, validateSearchQuery, SEARCH_MAILBOX_MESSAGE_BUDGET, GmailError, parseSearchQuery, CATEGORY_LABELS, parseDate, parseSize, KNOWN_FIELDS, parseDuration, assertHasOperator } from './chunk-PASFBRK4.js';
 export { DEFAULT_GMAIL_AGENT_EMAIL, GmailError, SEARCH_MAILBOX_MESSAGE_BUDGET, agentPathInboxMailbox, defaultSeedState, gmailErrorEnvelope, gmailSeedSchema, loadSeedFromEnv, parseSearchQuery, parseSeed, validateSearchQuery } from './chunk-PASFBRK4.js';
 import './chunk-JWJYNAWI.js';
-import { routeInputDeclarer, integerInput, booleanInput, repeatedInput, mountDeclaredRoute, UndeclaredInputError, MalformedBodyError } from './chunk-IZFM7W2V.js';
+import { routeInputDeclarer, integerInput, booleanInput, repeatedInput, mountDeclaredRoute, UndeclaredInputError, MalformedBodyError } from './chunk-GBMPR32X.js';
 import { loadMcpToolFixture, deriveMcpToolTable, defineTwin, openTwinDatabase, createApp } from './chunk-TWURH7YM.js';
 import './chunk-7VZBAHQ2.js';
 import './chunk-SG6ZTIMT.js';

package/dist/twinHarness-VEIXQJ4Y.js

@@ -0,0 +1,6 @@
+export { UnsupportedTwinError, bootTwin } from './chunk-QO6QJ6MN.js';
+export { STRIPE_LOCAL_ACCOUNT_ID } from './chunk-LDDR6XRN.js';
+import './chunk-TWURH7YM.js';
+import './chunk-7VZBAHQ2.js';
+import './chunk-SG6ZTIMT.js';
+import './chunk-FBSA5L36.js';

package/dist/{twinSeed-ZFZO7BL7.js → twinSeed-LDKR3NPY.js}

@@ -1,4 +1,4 @@
-import { TWIN_NAMES, isTwinName, TWIN_REGISTRY } from './chunk-BXYPNEJY.js';
+import { TWIN_NAMES, isTwinName, TWIN_REGISTRY } from './chunk-LDDR6XRN.js';
 import { writeFile } from 'node:fs/promises';
 
 async function generateSeedFile(twins) {

package/dist/{twinStart-XN3BYOUF.js → twinStart-44W63TRH.js}

@@ -1,17 +1,25 @@
-import { snapshotStandaloneInitialState, updateStandaloneStatusFile } from './chunk-AGZOWSLG.js';
-export { STANDALONE_STATUS_PATH, mergeStandaloneStatus, readStandaloneStatusFile, standaloneStatusEntries, updateStandaloneStatusFile, writeStandaloneStatusFile } from './chunk-AGZOWSLG.js';
-import { readSeedFileText, seedForTwin, parseSeedFileText, soleTwinOf, twinsNamedBy } from './chunk-DX2KCFJM.js';
-import { bootTwin } from './chunk-EZYVICDB.js';
-import { defaultPortFor, TWIN_REGISTRY, isTwinName, TWIN_NAMES } from './chunk-BXYPNEJY.js';
+import { snapshotStandaloneInitialState, updateStandaloneStatusFile, tapeRows, censusState, tapeSummary } from './chunk-4EPQF6CR.js';
+export { STANDALONE_STATUS_PATH, mergeStandaloneStatus, readStandaloneStatusFile, standaloneStatusEntries, updateStandaloneStatusFile, writeStandaloneStatusFile } from './chunk-4EPQF6CR.js';
+import { openBrowser, assetPath } from './chunk-TG6GFWA3.js';
+import { readSeedFileText, seedForTwin, parseSeedFileText, soleTwinOf, twinsNamedBy } from './chunk-GTLGXFLQ.js';
+import './chunk-NW7HGA2K.js';
+import { bootTwin } from './chunk-QO6QJ6MN.js';
+import './chunk-4LQ4IJOC.js';
+import './chunk-M7ATJ423.js';
+import { TWIN_REGISTRY, defaultPortFor, isTwinName, TWIN_NAMES } from './chunk-LDDR6XRN.js';
+import './chunk-NBOQN5VX.js';
+import './chunk-YBWG5JK2.js';
 import './chunk-TWURH7YM.js';
 import './chunk-7VZBAHQ2.js';
-import './chunk-SG6ZTIMT.js';
+import { redactSecrets } from './chunk-SG6ZTIMT.js';
+import './chunk-2K6BJ3PI.js';
 import './chunk-FBSA5L36.js';
-import { randomBytes } from 'node:crypto';
+import { randomBytes, timingSafeEqual } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { serve } from '@hono/node-server';
 import { sign } from 'hono/jwt';
+import { Hono } from 'hono';
 import { createServer } from 'node:net';
 
 // src/twin/connectSnippets.ts
@@ -39,6 +47,9 @@ function mcpJsonStanzaFor(inputs) {
   }
   return JSON.stringify({ mcpServers }, null, 2);
 }
+function mcpJsonStanza(input) {
+  return mcpJsonStanzaFor([input]);
+}
 function sdkLines(input) {
   const rest = `process.env.POME_${input.envName}_REST_URL`;
   switch (input.name) {
@@ -89,6 +100,9 @@ function exportLineFor(inputs) {
   }
   return `export ${pairs.join(" ")}`;
 }
+function exportLine(input) {
+  return exportLineFor([input]);
+}
 function indent(text) {
   return text.split("\n").map((line) => `  ${line}`).join("\n");
 }
@@ -116,6 +130,319 @@ function renderConnectSnippets(input) {
     sdkSections.join("\n\n")
   ].join("\n");
 }
+
+// src/dashboard/snapshot.ts
+var TAPE_WINDOW = 200;
+var readTwinOverHttp = async (twin) => {
+  const get = async (leaf) => {
+    const res = await fetch(`${twin.restUrl}/_pome/${leaf}`, {
+      headers: { Authorization: `Bearer ${twin.token}` },
+      signal: AbortSignal.timeout(2e3)
+    });
+    if (!res.ok) throw new Error(`${leaf} answered ${res.status}`);
+    return await res.json();
+  };
+  try {
+    const [events, state] = await Promise.all([get("events"), get("state")]);
+    return { events, state };
+  } catch {
+    return null;
+  }
+};
+function connectSnippetFor(twin) {
+  const input = {
+    name: twin.name,
+    envName: twin.envName,
+    port: Number(new URL(twin.restUrl).port),
+    restUrl: twin.restUrl,
+    mcpUrl: twin.mcpUrl,
+    token: twin.token,
+    ...twin.tokenEnvName ? { tokenEnvName: twin.tokenEnvName } : {}
+  };
+  const line = exportLine(input);
+  const claude = claudeCodeCommand(input);
+  return {
+    exportLine: line,
+    exportLineMasked: maskTokens(line, twin.token),
+    mcpJson: mcpJsonStanza(input),
+    claudeCode: claude,
+    claudeCodeMasked: maskTokens(claude, twin.token),
+    codexToml: codexConfigBlock(input)
+  };
+}
+function maskTokens(line, ...tokens) {
+  let out = line;
+  for (const token of tokens) {
+    if (token.length === 0) continue;
+    out = out.split(token).join("\u2022".repeat(28));
+  }
+  return out;
+}
+function entriesFor(rows, events) {
+  const start = Math.max(0, rows.length - TAPE_WINDOW);
+  return rows.slice(start).map((row, offset) => ({
+    ...row,
+    // `tapeRows` maps the event list one-to-one and in order, so index i on
+    // both sides is the same request. Read defensively anyway: a row without
+    // its event is a row whose detail panel says the twin reported nothing,
+    // which is a state the page already has to render honestly.
+    delta: deltaOf(events[start + offset])
+  }));
+}
+function deltaOf(event) {
+  if (event === null || typeof event !== "object") return null;
+  const delta = event.state_delta;
+  if (delta === null || typeof delta !== "object") return null;
+  const { before, after } = delta;
+  return {
+    before: isRecord(before) ? before : null,
+    after: isRecord(after) ? after : null
+  };
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+async function snapshotTwin(twin, read) {
+  const connect = connectSnippetFor(twin);
+  const base = {
+    name: twin.name,
+    url: twin.restUrl,
+    connect
+  };
+  const got = await read(twin);
+  if (got === null) {
+    return {
+      ...base,
+      reachable: false,
+      entries: [],
+      dropped: 0,
+      summary: { requests: 0, changed_state: 0, writes_not_landed: 0, unsupported: 0, reads: 0 },
+      world: []
+    };
+  }
+  const sessionPath = new URL(twin.restUrl).pathname;
+  const rows = tapeRows(got.events, sessionPath);
+  const events = Array.isArray(got.events) ? got.events : [];
+  return {
+    ...base,
+    reachable: true,
+    entries: entriesFor(rows, events),
+    dropped: Math.max(0, rows.length - TAPE_WINDOW),
+    // Over every row, not the windowed slice: the verdict line is a claim
+    // about the session, and a capped count would quietly under-report the
+    // one number this page exists to show.
+    summary: tapeSummary(rows),
+    world: censusState(twin.initialState, got.state)
+  };
+}
+async function buildSnapshot(twins, read = readTwinOverHttp) {
+  return {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    twins: await Promise.all(twins.map((twin) => snapshotTwin(twin, read)))
+  };
+}
+
+// src/dashboard/server.ts
+var PAGE_FILES = {
+  "/": { file: "index.html", type: "text/html; charset=utf-8" },
+  "/index.html": { file: "index.html", type: "text/html; charset=utf-8" },
+  "/app.js": { file: "app.js", type: "text/javascript; charset=utf-8" },
+  "/app.css": { file: "app.css", type: "text/css; charset=utf-8" }
+};
+var SCROLL_AREA_STYLE_HASH = "sha256-vGQdhYJbTuF+M8iCn1IZCHpdkiICocWHDq4qnQF4Rjw=";
+var DASHBOARD_CSP = [
+  "default-src 'none'",
+  "script-src 'self'",
+  `style-src 'self' '${SCROLL_AREA_STYLE_HASH}'`,
+  "font-src data:",
+  "img-src 'self' data:",
+  "connect-src 'self'",
+  "base-uri 'none'",
+  "form-action 'none'"
+].join("; ");
+function keyMatches(presented, expected) {
+  const a = Buffer.from(presented);
+  const b = Buffer.from(expected);
+  if (a.length !== b.length) return false;
+  return timingSafeEqual(a, b);
+}
+function isLoopbackHost(host) {
+  if (host === void 0) return false;
+  const name = host.replace(/:\d+$/, "").replace(/^\[|\]$/g, "");
+  return name === "127.0.0.1" || name === "localhost" || name === "::1";
+}
+function createDashboardApp(options) {
+  const app = new Hono();
+  app.use("*", async (c, next) => {
+    if (!isLoopbackHost(c.req.header("host"))) {
+      return c.text("This dashboard serves 127.0.0.1 only.", 403);
+    }
+    await next();
+  });
+  app.get("/api/snapshot", async (c) => {
+    if (!keyMatches(c.req.query("k") ?? "", options.key)) {
+      return c.json({ error: "not authorized for this dashboard" }, 401);
+    }
+    const snapshot = await buildSnapshot(options.twins, options.read);
+    c.header("cache-control", "no-store");
+    return c.json(snapshot);
+  });
+  app.get("*", (c) => {
+    const wanted = PAGE_FILES[new URL(c.req.url).pathname];
+    if (wanted === void 0) return c.text("Not found.", 404);
+    try {
+      const body = readFileSync(assetPath("dashboard", wanted.file));
+      c.header("content-type", wanted.type);
+      c.header("cache-control", "no-store");
+      c.header("content-security-policy", DASHBOARD_CSP);
+      return c.body(body);
+    } catch (err) {
+      return c.text(
+        `The dashboard page is not in this install.
+${err.message}
+Build it with \`npm run build -w @pome-sh/dashboard\`.`,
+        500
+      );
+    }
+  });
+  return app;
+}
+async function startDashboard(options) {
+  const key = randomBytes(16).toString("hex");
+  const app = createDashboardApp({ key, twins: options.twins, read: options.read });
+  const server = serve({
+    fetch: app.fetch,
+    port: options.port ?? 0,
+    hostname: "127.0.0.1"
+  });
+  const port = await new Promise((resolve, reject) => {
+    const onError = (err) => {
+      reject(
+        err.code === "EADDRINUSE" ? new Error(
+          `pome twin start: dashboard port ${options.port} is already in use \u2014 pass --dashboard-port <port>, or --no-dashboard.`
+        ) : err
+      );
+    };
+    server.once("error", onError);
+    server.once("listening", () => {
+      server.off("error", onError);
+      server.on("error", (err) => console.error(`pome twin start: dashboard error: ${err}`));
+      const address = server.address();
+      resolve(typeof address === "object" && address !== null ? address.port : 0);
+    });
+  });
+  return {
+    port,
+    url: `http://127.0.0.1:${port}/?k=${key}`,
+    close: async () => {
+      server.closeAllConnections?.();
+      await new Promise((resolve) => server.close(() => resolve()));
+    }
+  };
+}
+
+// src/twin/twinStartSeed.ts
+async function resolveStandaloneSeed(twin, seedPath, env = process.env, seedText, noSeed = false) {
+  if (seedPath !== void 0) {
+    const raw = seedText ?? readSeedFileText(seedPath, "pome twin start --seed");
+    const origin = `--seed ${seedPath}`;
+    return {
+      seedState: await seedForTwin(parseSeedFileText(raw, origin), twin, origin),
+      source: "file",
+      path: seedPath
+    };
+  }
+  const fromEnv = noSeed ? void 0 : env.POME_SEED_JSON;
+  if (fromEnv !== void 0 && fromEnv !== "") {
+    return {
+      seedState: await seedForTwin(
+        parseSeedFileText(fromEnv, "POME_SEED_JSON"),
+        twin,
+        "POME_SEED_JSON"
+      ),
+      source: "env"
+    };
+  }
+  return { seedState: await TWIN_REGISTRY[twin].defaultSeed(), source: "default" };
+}
+async function resolveStandaloneSeeds(twins, seedPath, env = process.env, seedText, noSeed = () => false) {
+  const out = /* @__PURE__ */ new Map();
+  if (twins.length === 1) {
+    const only = twins[0];
+    out.set(only, await resolveStandaloneSeed(only, seedPath, env, seedText, noSeed(only)));
+    return out;
+  }
+  for (const twin of twins.filter(noSeed)) {
+    out.set(twin, { seedState: await TWIN_REGISTRY[twin].defaultSeed(), source: "default" });
+  }
+  const seeded = twins.filter((twin) => !noSeed(twin));
+  if (seeded.length === 0) return out;
+  let authored;
+  if (seedPath !== void 0) {
+    authored = {
+      raw: seedText ?? readSeedFileText(seedPath, "pome twin start --seed"),
+      origin: `--seed ${seedPath}`,
+      source: "file",
+      path: seedPath
+    };
+  } else if (env.POME_SEED_JSON !== void 0 && env.POME_SEED_JSON !== "") {
+    authored = { raw: env.POME_SEED_JSON, origin: "POME_SEED_JSON", source: "env" };
+  }
+  if (authored === void 0) {
+    for (const twin of seeded) {
+      out.set(twin, { seedState: await TWIN_REGISTRY[twin].defaultSeed(), source: "default" });
+    }
+    return out;
+  }
+  const file = parseSeedFileText(authored.raw, authored.origin);
+  if (file.shape === "flat") {
+    throw new Error(
+      `${authored.origin} is a flat seed for one twin, and pome twin start was given ${twins.length} names (${twins.join(", ")}), so nothing says which one it is for. Name one twin, or wrap it in a per-twin envelope: { "${twins[0]}": { \u2026 } }.`
+    );
+  }
+  for (const twin of seeded) {
+    out.set(twin, {
+      seedState: await seedForTwin(file, twin, authored.origin),
+      source: authored.source,
+      ...authored.path !== void 0 ? { path: authored.path } : {}
+    });
+  }
+  return out;
+}
+
+// src/twin/twinDb.ts
+function resolveStandaloneDb(twin, seedPath, env = process.env) {
+  const { dbEnvName, noSeedEnvName } = TWIN_REGISTRY[twin];
+  const noSeed = env[noSeedEnvName] === "1";
+  if (noSeed && seedPath !== void 0) {
+    throw new Error(
+      `pome twin start: --seed ${seedPath} and ${noSeedEnvName}=1 contradict each other \u2014 one says apply this seed, the other says apply none. Drop one.`
+    );
+  }
+  return {
+    dbPath: env[dbEnvName] || ":memory:",
+    noSeed,
+    dbEnvName,
+    noSeedEnvName
+  };
+}
+function resolveStandaloneDbs(twins, seedPath, env = process.env) {
+  return new Map(twins.map((twin) => [twin, resolveStandaloneDb(twin, seedPath, env)]));
+}
+function renderStateLines(twin, seed, db) {
+  const inMemory = db.dbPath === ":memory:";
+  const seedLine = db.noSeed ? `Seed: not applied (${db.noSeedEnvName}=1).` : seed.source === "file" ? `Seed: ${seed.path} (replaces the ${twin} twin's default).` : seed.source === "env" ? `Seed: POME_SEED_JSON (replaces the ${twin} twin's default; --seed <path> overrides it).` : `Seed: the ${twin} twin's default (pass --seed <path>, or write one with \`pome twin new-seed ${twin}\`).`;
+  const stateLine = db.noSeed ? inMemory ? `State: in memory and unseeded, so this twin starts empty \u2014 point ${db.dbEnvName} at a saved db to serve one.` : `State: ${db.dbPath} (${db.dbEnvName}), served as it stands.` : inMemory ? `State: in memory \u2014 nothing survives Ctrl-C (set ${db.dbEnvName}=<path> to keep it).` : `State: ${db.dbPath} (${db.dbEnvName}), re-seeded on every boot \u2014 ${db.noSeedEnvName}=1 keeps what is there.`;
+  return `${seedLine}
+${stateLine}`;
+}
+function parseListenPort(raw, flag) {
+  const port = Number(raw);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new Error(`pome twin start: invalid ${flag} "${raw}"`);
+  }
+  return port;
+}
 async function isLoopbackPortFree(port) {
   return await new Promise((resolve) => {
     const probe = createServer();
@@ -124,13 +451,7 @@ async function isLoopbackPortFree(port) {
   });
 }
 async function chooseStandalonePorts(twins, portOption, env = process.env, isFree = isLoopbackPortFree) {
-  const parse = (raw) => {
-    const port = Number(raw);
-    if (!Number.isInteger(port) || port < 1 || port > 65535) {
-      throw new Error(`pome twin start: invalid --port "${raw}"`);
-    }
-    return port;
-  };
+  const parse = (raw) => parseListenPort(raw, "--port");
   if (twins.length === 1) return [parse(portOption ?? defaultPortFor(twins[0], env))];
   const chosen = [];
   for (const [index, twin] of twins.entries()) {
@@ -154,6 +475,9 @@ async function chooseStandalonePorts(twins, portOption, env = process.env, isFre
 }
 
 // src/twin/twinStart.ts
+async function bootBaseline(harness) {
+  return redactSecrets(await harness.exportState());
+}
 var STANDALONE_SID = "standalone";
 function resolveStandaloneAuthSecret(twin, env = process.env) {
   const injected = env.TWIN_AUTH_SECRET;
@@ -177,29 +501,6 @@ function resolveStandaloneAuthSecret(twin, env = process.env) {
   }
   return { secret: randomBytes(32).toString("hex"), source: "ephemeral" };
 }
-async function resolveStandaloneSeed(twin, seedPath, env = process.env, seedText) {
-  if (seedPath !== void 0) {
-    const raw = seedText ?? readSeedFileText(seedPath, "pome twin start --seed");
-    const origin = `--seed ${seedPath}`;
-    return {
-      seedState: await seedForTwin(parseSeedFileText(raw, origin), twin, origin),
-      source: "file",
-      path: seedPath
-    };
-  }
-  const fromEnv = env.POME_SEED_JSON;
-  if (fromEnv !== void 0 && fromEnv !== "") {
-    return {
-      seedState: await seedForTwin(
-        parseSeedFileText(fromEnv, "POME_SEED_JSON"),
-        twin,
-        "POME_SEED_JSON"
-      ),
-      source: "env"
-    };
-  }
-  return { seedState: await TWIN_REGISTRY[twin].defaultSeed(), source: "default" };
-}
 function resolveStandaloneTwin(name, seedPath, seedText) {
   if (name !== void 0) {
     if (!isTwinName(name)) {
@@ -237,45 +538,6 @@ function resolveStandaloneTwins(names, seedPath, seedText) {
   }
   return twins;
 }
-async function resolveStandaloneSeeds(twins, seedPath, env = process.env, seedText) {
-  const out = /* @__PURE__ */ new Map();
-  if (twins.length === 1) {
-    const only = twins[0];
-    out.set(only, await resolveStandaloneSeed(only, seedPath, env, seedText));
-    return out;
-  }
-  let authored;
-  if (seedPath !== void 0) {
-    authored = {
-      raw: seedText ?? readSeedFileText(seedPath, "pome twin start --seed"),
-      origin: `--seed ${seedPath}`,
-      source: "file",
-      path: seedPath
-    };
-  } else if (env.POME_SEED_JSON !== void 0 && env.POME_SEED_JSON !== "") {
-    authored = { raw: env.POME_SEED_JSON, origin: "POME_SEED_JSON", source: "env" };
-  }
-  if (authored === void 0) {
-    for (const twin of twins) {
-      out.set(twin, { seedState: await TWIN_REGISTRY[twin].defaultSeed(), source: "default" });
-    }
-    return out;
-  }
-  const file = parseSeedFileText(authored.raw, authored.origin);
-  if (file.shape === "flat") {
-    throw new Error(
-      `${authored.origin} is a flat seed for one twin, and pome twin start was given ${twins.length} names (${twins.join(", ")}), so nothing says which one it is for. Name one twin, or wrap it in a per-twin envelope: { "${twins[0]}": { \u2026 } }.`
-    );
-  }
-  for (const twin of twins) {
-    out.set(twin, {
-      seedState: await seedForTwin(file, twin, authored.origin),
-      source: authored.source,
-      ...authored.path !== void 0 ? { path: authored.path } : {}
-    });
-  }
-  return out;
-}
 function resolveStandaloneAuthSecretFor(twins, env = process.env, resolveOne = resolveStandaloneAuthSecret) {
   if (twins.length === 1) return resolveOne(twins[0], env);
   if (env.TWIN_AUTH_SECRET) return { secret: env.TWIN_AUTH_SECRET, source: "env" };
@@ -294,8 +556,16 @@ async function runTwinStartCommand(namesArg, options) {
   const names = namesArg === void 0 ? [] : typeof namesArg === "string" ? [namesArg] : [...namesArg];
   const seedText = options.seed === void 0 ? void 0 : readSeedFileText(options.seed, "pome twin start --seed");
   const twins = resolveStandaloneTwins(names, options.seed, seedText);
+  const dbs = resolveStandaloneDbs(twins, options.seed, process.env);
+  const dashboardPort = options.dashboardPort === void 0 ? void 0 : parseListenPort(options.dashboardPort, "--dashboard-port");
   const ports = await chooseStandalonePorts(twins, options.port, process.env);
-  const seeds = await resolveStandaloneSeeds(twins, options.seed, process.env, seedText);
+  const seeds = await resolveStandaloneSeeds(
+    twins,
+    options.seed,
+    process.env,
+    seedText,
+    (twin) => dbs.get(twin).noSeed
+  );
   const resolved = resolveStandaloneAuthSecretFor(twins);
   process.env.TWIN_AUTH_SECRET = resolved.secret;
   const booted = [];
@@ -307,10 +577,13 @@ async function runTwinStartCommand(namesArg, options) {
         twin,
         seedState: seeds.get(twin).seedState,
         runId: STANDALONE_SID,
-        twinBaseUrl: baseUrl
+        twinBaseUrl: baseUrl,
+        dbPath: dbs.get(twin).dbPath,
+        noSeed: dbs.get(twin).noSeed
       });
-      booted.push({ twin, port, baseUrl, harness });
-      await snapshotStandaloneInitialState(twin, () => harness.exportState());
+      const initialState = await bootBaseline(harness);
+      booted.push({ twin, port, baseUrl, harness, initialState });
+      await snapshotStandaloneInitialState(twin, () => initialState);
     }
   } catch (err) {
     for (const entry of booted) await entry.harness.close();
@@ -329,7 +602,9 @@ async function runTwinStartCommand(namesArg, options) {
     resolved.secret
   );
   const servers = [];
+  let dashboard;
   const closeAll = async () => {
+    await dashboard?.close();
     for (const server of servers) {
       server.closeAllConnections?.();
       await new Promise((resolve) => server.close(() => resolve()));
@@ -370,19 +645,8 @@ async function runTwinStartCommand(namesArg, options) {
     const { twin: name, port, baseUrl, harness } = entry;
     const restUrl = `${baseUrl}/s/${STANDALONE_SID}`;
     const mcpUrl = `${restUrl}/mcp`;
-    const world = seeds.get(name);
     console.log(`Pome ${name} twin listening at ${restUrl}`);
-    if (world.source === "file") {
-      console.log(`Seed: ${world.path} (replaces the ${name} twin's default).`);
-    } else if (world.source === "env") {
-      console.log(
-        `Seed: POME_SEED_JSON (replaces the ${name} twin's default; --seed <path> overrides it).`
-      );
-    } else {
-      console.log(
-        `Seed: the ${name} twin's default (pass --seed <path>, or write one with \`pome twin new-seed ${name}\`).`
-      );
-    }
+    console.log(renderStateLines(name, seeds.get(name), dbs.get(name)));
     if (index === 0 && resolved.source === "persisted") {
       console.log(
         `Auth: using the persisted secret from ${resolved.path} (an env-injected TWIN_AUTH_SECRET overrides it).`
@@ -405,6 +669,28 @@ async function runTwinStartCommand(namesArg, options) {
   }
   console.log("");
   console.log(renderConnectSnippets(connect));
+  if (options.dashboard !== false) {
+    try {
+      dashboard = await startDashboard({
+        twins: booted.map((entry) => ({
+          name: entry.twin,
+          restUrl: `${entry.baseUrl}/s/${STANDALONE_SID}`,
+          mcpUrl: `${entry.baseUrl}/s/${STANDALONE_SID}/mcp`,
+          token,
+          envName: entry.harness.envName,
+          ...entry.harness.tokenEnvName ? { tokenEnvName: entry.harness.tokenEnvName } : {},
+          initialState: entry.initialState
+        })),
+        ...dashboardPort === void 0 ? {} : { port: dashboardPort }
+      });
+      console.log("");
+      console.log(`Dashboard: ${dashboard.url}`);
+      console.log("  Open it in a browser to watch the tape while the agent works.");
+      if (options.open === true) void openBrowser(dashboard.url);
+    } catch (err) {
+      console.error(`Dashboard not started: ${err.message}`);
+    }
+  }
   console.log("");
   console.log("Ctrl-C to stop.");
   const shutdown = () => {
@@ -419,4 +705,4 @@ async function runTwinStartCommand(namesArg, options) {
   process.once("SIGTERM", shutdown);
 }
 
-export { chooseStandalonePorts, isLoopbackPortFree, resolveStandaloneAuthSecret, resolveStandaloneAuthSecretFor, resolveStandaloneSeed, resolveStandaloneSeeds, resolveStandaloneTwin, resolveStandaloneTwins, runTwinStartCommand };
+export { bootBaseline, chooseStandalonePorts, isLoopbackPortFree, parseListenPort, resolveStandaloneAuthSecret, resolveStandaloneAuthSecretFor, resolveStandaloneSeed, resolveStandaloneSeeds, resolveStandaloneTwin, resolveStandaloneTwins, runTwinStartCommand };

package/dist/twinTape-433A4IC4.js

@@ -0,0 +1,10 @@
+export { graphqlOperationKind, pickRecordedTwin, renderTape, requestKind, requestLabel, runTwinTapeCommand, tapeRows, tapeSummary } from './chunk-4EPQF6CR.js';
+import './chunk-4LQ4IJOC.js';
+import './chunk-M7ATJ423.js';
+import './chunk-LDDR6XRN.js';
+import './chunk-NBOQN5VX.js';
+import './chunk-YBWG5JK2.js';
+import './chunk-7VZBAHQ2.js';
+import './chunk-SG6ZTIMT.js';
+import './chunk-2K6BJ3PI.js';
+import './chunk-FBSA5L36.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pome-sh/cli",
-  "version": "0.45.1",
+  "version": "0.46.0",
   "description": "Test mode for your integrations, built for the way agents build. Local, stateful twins of GitHub, Slack, Stripe, Gmail and Linear, over REST and MCP.",
   "keywords": [
     "mcp",
@@ -75,6 +75,7 @@
     "zod": "^4.6.5"
   },
   "devDependencies": {
+    "@pome-sh/dashboard": "*",
     "@pome-sh/sdk": "*",
     "@pome-sh/wire": "*",
     "@pome-sh/twin-github": "*",