@pome-sh/cli 0.19.0 → 0.21.0

package/dist/chunk-RGZBC7NF.js

@@ -0,0 +1,90 @@
+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)}`;
+}
+
+// src/demo/render.ts
+function reassuranceBox() {
+  const lines = [
+    "pome demo \xB7 running locally",
+    "No signup. No API keys.",
+    "The GitHub twin runs on your machine; model calls go through pome's",
+    "anonymous demo gateway; the trace is evaluated in pome cloud.",
+    "Your repo and your data are never touched."
+  ];
+  const width = Math.max(...lines.map((line) => line.length));
+  const top = `\u250C${"\u2500".repeat(width + 2)}\u2510`;
+  const bottom = `\u2514${"\u2500".repeat(width + 2)}\u2518`;
+  return [top, ...lines.map((line) => `\u2502 ${line.padEnd(width)} \u2502`), bottom];
+}
+function twinReadyLine(seconds) {
+  return `spinning up github twin \u2026 ready (${seconds.toFixed(1)}s)`;
+}
+function trialsHeaderLine(count, taskName) {
+  return `running ${count} isolated trials of ${taskName} \u2026`;
+}
+function evaluatingLine(index) {
+  return `trial ${index}  \u2026  evaluating in the cloud \u2026`;
+}
+function trialLine(index, verdict) {
+  switch (verdict.kind) {
+    case "passed":
+      return `trial ${index}  \u2713  passed   ${formatSeconds(verdict.seconds)}`;
+    case "failed":
+      return `trial ${index}  \u2717  failed   ${formatSeconds(verdict.seconds)}  ${verdict.note}`;
+    case "errored":
+      return `trial ${index}  \u26A0  errored         ${verdict.reason} \u2014 excluded`;
+  }
+}
+function formatSeconds(seconds) {
+  return `${seconds.toFixed(1)}s`;
+}
+function summaryLines(input) {
+  const passed = input.verdicts.filter((v) => v.kind === "passed").length;
+  const failed = input.verdicts.filter((v) => v.kind === "failed").length;
+  const errored = input.verdicts.filter(
+    (v) => v.kind === "errored"
+  );
+  const denominator = passed + failed;
+  const lines = ["\u2500\u2500\u2500\u2500\u2500"];
+  let fraction;
+  if (denominator === 0) {
+    fraction = "no trials were evaluated";
+  } else {
+    fraction = `${passed} of ${denominator} passed`;
+  }
+  if (errored.length > 0) {
+    const reason = errored[0].reason;
+    const noun = errored.length === 1 ? "trial" : "trials";
+    fraction += ` \xB7 ${errored.length} ${noun} errored on ${reason}, excluded from the fraction`;
+  }
+  lines.push(fraction);
+  if (input.failingCriterionPhrase && typeof input.failingCriterionCount === "number" && input.failingCriterionCount > 0 && denominator > 0) {
+    lines.push(
+      `${input.failingCriterionPhrase} in ${input.failingCriterionCount} of ${denominator} \u2014 start there`
+    );
+  }
+  if (denominator > 0) {
+    lines.push("see the full breakdown \u2014 read-only, still no account:");
+    lines.push(`\u2192 ${input.previewUrl}`);
+  }
+  return lines;
+}
+function criterionPhrase(text) {
+  const clause = text.split(/[.;]/)[0]?.trim() ?? text.trim();
+  const lowered = clause.length > 0 ? clause[0].toLowerCase() + clause.slice(1) : clause;
+  return lowered.length > 64 ? `${lowered.slice(0, 61).trimEnd()}\u2026` : lowered;
+}
+
+export { criterionPhrase, evaluatingLine, newGroupId, reassuranceBox, summaryLines, trialLine, trialsHeaderLine, twinReadyLine };

package/dist/chunk-SG6ZTIMT.js

@@ -0,0 +1,145 @@
+// ../packages/wire/dist/redaction.js
+var REDACTED = "[REDACTED]";
+var HARD_REDACT_KEYS = /* @__PURE__ */ new Set([
+  "authorization",
+  "x-api-key",
+  "cookie",
+  "api_key",
+  "client_secret",
+  "webhook_secret",
+  "password",
+  "secret",
+  "token",
+  "access_token",
+  "refresh_token",
+  "session_token",
+  "agent_token",
+  "anthropic_api_key"
+]);
+function base64UrlRunEnd(value, from) {
+  let i = from;
+  while (i < value.length) {
+    const code = value.charCodeAt(i);
+    const isBase64Url = code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 45 || code === 95;
+    if (!isBase64Url)
+      break;
+    i += 1;
+  }
+  return i;
+}
+function scrubJwts(value) {
+  let out = "";
+  let copied = 0;
+  let search = 0;
+  while (true) {
+    const start = value.indexOf("eyJ", search);
+    if (start === -1)
+      break;
+    const header = base64UrlRunEnd(value, start + 3);
+    if (header === start + 3) {
+      search = start + 1;
+      continue;
+    }
+    if (value.charCodeAt(header) !== 46) {
+      search = header;
+      continue;
+    }
+    const payload = base64UrlRunEnd(value, header + 1);
+    if (payload === header + 1 || value.charCodeAt(payload) !== 46) {
+      search = header;
+      continue;
+    }
+    const end = base64UrlRunEnd(value, payload + 1);
+    out += value.slice(copied, start) + REDACTED;
+    copied = end;
+    search = end;
+  }
+  return copied === 0 ? value : out + value.slice(copied);
+}
+function pemHeaderEnd(value, at, keyword) {
+  const labelStart = at + keyword.length;
+  let labelEnd = labelStart;
+  while (labelEnd < value.length) {
+    const code = value.charCodeAt(labelEnd);
+    if (!(code >= 65 && code <= 90 || code === 32))
+      break;
+    labelEnd += 1;
+  }
+  if (labelEnd === labelStart)
+    return -1;
+  if (!value.startsWith("-----", labelEnd))
+    return -1;
+  return labelEnd + 5;
+}
+function scrubPemBlocks(value) {
+  let out = "";
+  let copied = 0;
+  let search = 0;
+  while (true) {
+    const begin = value.indexOf("-----BEGIN ", search);
+    if (begin === -1)
+      break;
+    const bodyStart = pemHeaderEnd(value, begin, "-----BEGIN ");
+    if (bodyStart === -1) {
+      search = begin + 1;
+      continue;
+    }
+    let endSearch = bodyStart;
+    let blockEnd = -1;
+    while (true) {
+      const end = value.indexOf("-----END ", endSearch);
+      if (end === -1)
+        break;
+      blockEnd = pemHeaderEnd(value, end, "-----END ");
+      if (blockEnd !== -1)
+        break;
+      endSearch = end + 1;
+    }
+    if (blockEnd === -1)
+      break;
+    out += value.slice(copied, begin) + REDACTED;
+    copied = blockEnd;
+    search = blockEnd;
+  }
+  return copied === 0 ? value : out + value.slice(copied);
+}
+var SCRUB_STEPS = [
+  /redaction_fixture_secret_[A-Za-z0-9_-]{8,}/g,
+  /\bsk-[A-Za-z0-9_-]{20,}/g,
+  /\b[rs]k_(?:test|live)_[A-Za-z0-9_]{4,}/g,
+  /ghp_[A-Za-z0-9]{36}/g,
+  /github_pat_[A-Za-z0-9_]{20,}/g,
+  /xox[aboprs]-[A-Za-z0-9-]{20,}/g,
+  /xapp-[A-Za-z0-9-]{10,}/g,
+  /(?:pme|pk|rk)_[A-Za-z0-9_-]{20,}/g,
+  /AIza[0-9A-Za-z_-]{20,}/g,
+  /AKIA[0-9A-Z]{16}/g,
+  scrubJwts,
+  scrubPemBlocks,
+  /-----BEGIN [A-Z ]+-----/g
+];
+function scrubString(value) {
+  let out = value;
+  for (const step of SCRUB_STEPS) {
+    out = typeof step === "function" ? step(out) : out.replace(step, REDACTED);
+  }
+  return out;
+}
+function redactSecrets(value) {
+  if (typeof value === "string")
+    return scrubString(value);
+  if (Array.isArray(value))
+    return value.map(redactSecrets);
+  if (value && typeof value === "object") {
+    return Object.fromEntries(Object.entries(value).map(([key, nested]) => [
+      key,
+      HARD_REDACT_KEYS.has(key.toLowerCase()) ? REDACTED : redactSecrets(nested)
+    ]));
+  }
+  return value;
+}
+function redactEvent(event) {
+  return redactSecrets(event);
+}
+
+export { redactEvent, redactSecrets };

package/dist/chunk-VBATFCWR.js

@@ -0,0 +1,442 @@
+import { z } from 'zod';
+
+// ../packages/wire/dist/recorder-events.js
+var twinIdSchema = z.string().min(1);
+var recorderFidelitySchema = z.enum(["semantic", "unsupported"]);
+var stateDeltaSchema = z.object({
+  before: z.record(z.string(), z.unknown()).nullable(),
+  after: z.record(z.string(), z.unknown()).nullable()
+}).nullable();
+var recorderEventObjectSchema = z.object({
+  ts: z.string().datetime(),
+  run_id: z.string().min(1),
+  twin: twinIdSchema,
+  request_id: z.string().min(1),
+  correlation_id: z.string().min(1).optional(),
+  // task_step_id is set by the task author in .yaml (static expectation:
+  // "this HTTP call is expected at step 2"). step_id below is set post-hoc by
+  // the correlator (dynamic grouping: "this event landed in Step stp_xyz").
+  // 90% of events use only one; both can coexist.
+  //
+  // W3 vocab (FDRS-653): `task_step_id` is canonical; `scenario_step_id` is
+  // the 0.3.0-era spelling. BOTH stay in the schema for the tolerant-reader
+  // window — this row shape is the frozen v1 trace format and its emitters
+  // (twin runtimes, shipped CLIs on vendored 0.3.0) still write the old key.
+  // The exported reader schemas normalize: when only `scenario_step_id` is
+  // present, `task_step_id` is populated from it at parse time. New emitters
+  // write `task_step_id`.
+  task_step_id: z.string().min(1).nullable().optional(),
+  scenario_step_id: z.string().min(1).nullable().optional(),
+  step_id: z.string().nullable(),
+  // tool_call_id is set by the `@pome-sh/adapter-claude-sdk` adapter when active.
+  // Null for the heuristic-correlator path (no adapter signal available).
+  tool_call_id: z.string().nullable(),
+  method: z.string().min(1),
+  path: z.string(),
+  request_body: z.unknown(),
+  // F-1125 — the request headers as received, keys lowercased by the runtime.
+  //
+  // Recorded WHOLESALE rather than through an allowlist. An allowlist is a
+  // narrowing no downstream consumer can lift and no task author can extend,
+  // which is the defect this field exists to remove: `The retry includes
+  // X-PAYMENT` was unanswerable at any substrate width because the recorder
+  // captured nothing. Secrets are handled where every other field's are —
+  // `redactEvent` runs unconditionally before any store sees the event, and
+  // `HARD_REDACT_KEYS` already covers `authorization` / `cookie` / `x-api-key`
+  // by key. Asserted both ways in `packages/sdk/test/redaction.test.ts`: the
+  // bearer must not survive, and `x-payment` must.
+  //
+  // Optional, not nullable: ABSENT means this row predates F-1125, and a
+  // present-but-empty map would erase that distinction. A required field here
+  // would be far worse than a missing one — `twinHttpEventSchema` is the only
+  // gate into the cloud's tape and a row that fails it is dropped SILENTLY, so
+  // every recording an older CLI wrote would arrive as an empty tape, which for
+  // a negative criterion is a free pass.
+  request_headers: z.record(z.string(), z.string()).optional(),
+  // F-1125 — the twin ACTION this call invoked, when the twin declares one for
+  // the surface that served it. This is the field that stops a tape check from
+  // reverse-engineering a tool name out of an MCP transport path.
+  //
+  // It names the action, NOT the transport. The same fabrication reaches the
+  // GitHub twin two ways — `tools/call` with `create_commit_status`, and
+  // `POST /repos/:owner/:repo/statuses/:sha` — and both stamp the same value.
+  // A field that only carried the MCP name would leave the REST door open, and
+  // `create_commit_status was never called` would pass over a run that called
+  // it: the negative false-pass D4 forbids, relocated rather than fixed.
+  //
+  // The value is the action the CALLER NAMED, stamped even when the call then
+  // failed (unknown tool, validation error, 4xx). "Was it called" is a question
+  // about the attempt, and a check that cares whether it succeeded has `status`
+  // on the same row.
+  //
+  // `null` means "no declared action for this surface" — NOT "no action". Only
+  // surfaces a twin has stamped are assertable; the GitHub twin's
+  // `TAPE_ASSERTABLE_TOOLS` is the set that has been, and its check's param type
+  // is generated from that set so a criterion cannot name an unstamped action.
+  tool: z.string().min(1).nullable().optional(),
+  status: z.number().int(),
+  response_body: z.unknown(),
+  latency_ms: z.number().int().min(0),
+  fidelity: recorderFidelitySchema,
+  state_mutation: z.boolean(),
+  state_delta: stateDeltaSchema,
+  // True iff the twin's idempotency layer replayed a cached response without
+  // re-invoking the handler. Optional + additive so existing recordings parse
+  // unchanged; dashboards/SDKs can render dedupe hits distinctly without
+  // inferring from request_body. Absent on the original mutation, present and
+  // true on the replayed event.
+  idempotency_dedupe: z.boolean().optional(),
+  error: z.string().nullable()
+});
+function normalizeTaskStepVocab(event) {
+  if (event.task_step_id == null && event.scenario_step_id != null) {
+    return { ...event, task_step_id: event.scenario_step_id };
+  }
+  return event;
+}
+function normalizeParentVocab(event) {
+  return event.parent_event_id === void 0 ? { ...event, parent_event_id: event.parent_id ?? null } : event;
+}
+function normalizeHookCausingToolUseId(event) {
+  return {
+    ...event,
+    causing_tool_use_id: event.causing_tool_use_id === void 0 ? event.parent_id ?? null : event.causing_tool_use_id,
+    parent_event_id: null
+  };
+}
+recorderEventObjectSchema.transform(normalizeTaskStepVocab);
+var eventBaseShape = {
+  ts: z.string().datetime(),
+  event_id: z.string().min(1),
+  parent_event_id: z.string().min(1).nullable().optional(),
+  parent_id: z.string().min(1).nullable().optional()
+};
+var twinHttpEventSchema = recorderEventObjectSchema.extend({
+  kind: z.literal("TwinHttpEvent"),
+  event_id: z.string().min(1),
+  parent_event_id: z.string().min(1).nullable().optional(),
+  parent_id: z.string().min(1).nullable().optional()
+});
+var llmCallEventSchema = z.object({
+  ...eventBaseShape,
+  kind: z.literal("LlmCallEvent"),
+  // Baseline (always populated)
+  host: z.string().min(1),
+  port: z.number().int().min(1).max(65535),
+  latency_ms: z.number().int().min(0),
+  bytes_in: z.number().int().min(0),
+  bytes_out: z.number().int().min(0),
+  // TLS-terminate-only — nullable, not optional. Writers must emit explicit
+  // null in baseline/CAS mode so the on-disk JSON shape is stable.
+  url: z.string().nullable(),
+  method: z.string().nullable(),
+  status: z.number().int().nullable(),
+  model: z.string().nullable(),
+  prompt_tokens: z.number().int().min(0).nullable(),
+  completion_tokens: z.number().int().min(0).nullable(),
+  cost_usd: z.number().nullable()
+});
+var toolUseEventSchema = z.object({
+  ...eventBaseShape,
+  kind: z.literal("ToolUseEvent"),
+  tool_use_id: z.string().min(1),
+  tool_name: z.string().min(1),
+  input: z.unknown()
+});
+var toolResultEventSchema = z.object({
+  ...eventBaseShape,
+  kind: z.literal("ToolResultEvent"),
+  tool_use_id: z.string().min(1),
+  output: z.unknown(),
+  is_error: z.boolean()
+});
+var subagentSpawnEventSchema = z.object({
+  ...eventBaseShape,
+  kind: z.literal("SubagentSpawnEvent"),
+  parent_tool_use_id: z.string().min(1)
+});
+var hookEventSchema = z.object({
+  ...eventBaseShape,
+  kind: z.literal("HookEvent"),
+  hook_name: z.string().min(1),
+  tool_name: z.string().min(1).nullable(),
+  causing_tool_use_id: z.string().min(1).nullable().optional()
+});
+var llmTurnEventSchema = z.object({
+  ...eventBaseShape,
+  kind: z.literal("LlmTurnEvent"),
+  turn_index: z.number().int().min(0),
+  model: z.string().min(1).nullable(),
+  input_tokens: z.number().int().min(0).nullable(),
+  output_tokens: z.number().int().min(0).nullable(),
+  cache_read_input_tokens: z.number().int().min(0).nullable(),
+  cache_creation_input_tokens: z.number().int().min(0).nullable(),
+  // OTel `gen_ai.response.finish_reasons` is an array; Anthropic reports one
+  // `stop_reason` per turn. null when the SDK surfaced none.
+  finish_reasons: z.array(z.string()).nullable(),
+  latency_ms: z.number().int().min(0),
+  latency_ms_estimated: z.boolean(),
+  session_id: z.string().min(1).nullable()
+});
+var eventUnionSchema = z.discriminatedUnion("kind", [
+  twinHttpEventSchema,
+  llmCallEventSchema,
+  toolUseEventSchema,
+  toolResultEventSchema,
+  subagentSpawnEventSchema,
+  hookEventSchema,
+  llmTurnEventSchema
+]);
+var eventSchema = eventUnionSchema.transform((event) => {
+  if (event.kind === "TwinHttpEvent")
+    return normalizeParentVocab(normalizeTaskStepVocab(event));
+  if (event.kind === "HookEvent")
+    return normalizeHookCausingToolUseId(event);
+  return normalizeParentVocab(event);
+});
+function isLegacyEventRow(row) {
+  if (typeof row !== "object" || row === null || Array.isArray(row)) {
+    return false;
+  }
+  return typeof row.kind !== "string";
+}
+
+// ../packages/wire/dist/otel/semconv.js
+var GEN_AI_PROVIDER_NAME = "gen_ai.provider.name";
+var GEN_AI_SYSTEM_DEPRECATED = "gen_ai.system";
+var GEN_AI_OPERATION_NAME = "gen_ai.operation.name";
+var GEN_AI_REQUEST_MODEL = "gen_ai.request.model";
+var GEN_AI_AGENT_NAME = "gen_ai.agent.name";
+var GEN_AI_AGENT_ID = "gen_ai.agent.id";
+var GEN_AI_TOOL_NAME = "gen_ai.tool.name";
+var GEN_AI_USAGE_INPUT_TOKENS = "gen_ai.usage.input_tokens";
+var GEN_AI_USAGE_OUTPUT_TOKENS = "gen_ai.usage.output_tokens";
+var GEN_AI_USAGE_PROMPT_TOKENS_LEGACY = "gen_ai.usage.prompt_tokens";
+var GEN_AI_USAGE_COMPLETION_TOKENS_LEGACY = "gen_ai.usage.completion_tokens";
+var OPENINFERENCE_LLM_MODEL_NAME = "llm.model_name";
+var OPENINFERENCE_LLM_PROVIDER = "llm.provider";
+var OPENINFERENCE_LLM_SYSTEM = "llm.system";
+var OPENINFERENCE_LLM_TOKEN_COUNT_PROMPT = "llm.token_count.prompt";
+var OPENINFERENCE_LLM_TOKEN_COUNT_COMPLETION = "llm.token_count.completion";
+var OPENINFERENCE_TOOL_NAME = "tool.name";
+var HTTP_REQUEST_METHOD = "http.request.method";
+var HTTP_RESPONSE_STATUS_CODE = "http.response.status_code";
+var URL_FULL = "url.full";
+var URL_PATH = "url.path";
+var SERVER_ADDRESS = "server.address";
+var SERVER_PORT = "server.port";
+var ERROR_TYPE = "error.type";
+
+// ../packages/wire/dist/otel/nano.js
+var UINT64_MAX = "18446744073709551615";
+function normalizeDigits(value) {
+  return value.replace(/^0+(?=\d)/, "");
+}
+function isUint64(value) {
+  if (!/^\d+$/.test(value))
+    return false;
+  const normalized = normalizeDigits(value);
+  if (normalized.length !== UINT64_MAX.length) {
+    return normalized.length < UINT64_MAX.length;
+  }
+  return normalized <= UINT64_MAX;
+}
+function compareUint64(a, b) {
+  const na = normalizeDigits(a);
+  const nb = normalizeDigits(b);
+  if (na.length !== nb.length)
+    return na.length - nb.length;
+  if (na === nb)
+    return 0;
+  return na < nb ? -1 : 1;
+}
+function nanosToIso(unixNano) {
+  const millis = Number(unixNano.slice(0, -6) || "0");
+  return new Date(millis).toISOString();
+}
+var finiteNumber = z.number().finite();
+var otelAttributeValueSchema = z.union([
+  z.string(),
+  finiteNumber,
+  z.boolean(),
+  z.array(z.union([z.string(), finiteNumber, z.boolean()]))
+]);
+var OTEL_PROJECTION_KEYS = [
+  "gen_ai_provider_name",
+  "gen_ai_operation_name",
+  "gen_ai_request_model",
+  "gen_ai_agent_name",
+  "gen_ai_agent_id",
+  "gen_ai_tool_name",
+  "gen_ai_usage_input_tokens",
+  "gen_ai_usage_output_tokens",
+  "http_request_method",
+  "http_response_status_code",
+  "url_full",
+  "url_path",
+  "server_address",
+  "server_port",
+  "error_type"
+];
+function readString(attributes, key) {
+  const value = attributes[key];
+  return typeof value === "string" ? value : null;
+}
+function readInt(attributes, key) {
+  const value = attributes[key];
+  return typeof value === "number" && Number.isInteger(value) ? value : null;
+}
+function readUint(attributes, key) {
+  const value = readInt(attributes, key);
+  return value !== null && value >= 0 ? value : null;
+}
+function projectAttributes(attributes) {
+  return {
+    // provider: canonical → deprecated gen_ai.system → OpenInference llm.provider
+    // → OpenInference llm.system (the LangChain provider label).
+    gen_ai_provider_name: readString(attributes, GEN_AI_PROVIDER_NAME) ?? readString(attributes, GEN_AI_SYSTEM_DEPRECATED) ?? readString(attributes, OPENINFERENCE_LLM_PROVIDER) ?? readString(attributes, OPENINFERENCE_LLM_SYSTEM),
+    gen_ai_operation_name: readString(attributes, GEN_AI_OPERATION_NAME),
+    gen_ai_request_model: readString(attributes, GEN_AI_REQUEST_MODEL) ?? readString(attributes, OPENINFERENCE_LLM_MODEL_NAME),
+    gen_ai_agent_name: readString(attributes, GEN_AI_AGENT_NAME),
+    gen_ai_agent_id: readString(attributes, GEN_AI_AGENT_ID),
+    gen_ai_tool_name: readString(attributes, GEN_AI_TOOL_NAME) ?? readString(attributes, OPENINFERENCE_TOOL_NAME),
+    gen_ai_usage_input_tokens: readUint(attributes, GEN_AI_USAGE_INPUT_TOKENS) ?? readUint(attributes, GEN_AI_USAGE_PROMPT_TOKENS_LEGACY) ?? readUint(attributes, OPENINFERENCE_LLM_TOKEN_COUNT_PROMPT),
+    gen_ai_usage_output_tokens: readUint(attributes, GEN_AI_USAGE_OUTPUT_TOKENS) ?? readUint(attributes, GEN_AI_USAGE_COMPLETION_TOKENS_LEGACY) ?? readUint(attributes, OPENINFERENCE_LLM_TOKEN_COUNT_COMPLETION),
+    http_request_method: readString(attributes, HTTP_REQUEST_METHOD),
+    // HTTP status codes are non-negative (100–599); `readUint` drops a bogus
+    // negative value rather than projecting it as a valid code.
+    http_response_status_code: readUint(attributes, HTTP_RESPONSE_STATUS_CODE),
+    url_full: readString(attributes, URL_FULL),
+    url_path: readString(attributes, URL_PATH),
+    server_address: readString(attributes, SERVER_ADDRESS),
+    server_port: readUint(attributes, SERVER_PORT),
+    error_type: readString(attributes, ERROR_TYPE)
+  };
+}
+var OTEL_SPAN_KINDS = [
+  "UNSPECIFIED",
+  "INTERNAL",
+  "SERVER",
+  "CLIENT",
+  "PRODUCER",
+  "CONSUMER"
+];
+var otelSpanKindSchema = z.enum(OTEL_SPAN_KINDS);
+var OTEL_STATUS_CODES = ["UNSET", "OK", "ERROR"];
+var otelStatusCodeSchema = z.enum(OTEL_STATUS_CODES);
+var unixNanoSchema = z.string().refine(isUint64, "expected a uint64 decimal string (unix nanoseconds) within range");
+var NON_ZERO = (hex) => /[1-9a-f]/.test(hex);
+var w3cTraceIdSchema = z.string().regex(/^[0-9a-f]{32}$/, "expected a 32-char lowercase-hex W3C trace id").refine(NON_ZERO, "trace id must not be all-zero");
+var w3cSpanIdSchema = z.string().regex(/^[0-9a-f]{16}$/, "expected a 16-char lowercase-hex W3C span id").refine(NON_ZERO, "span id must not be all-zero");
+var legacyIdSchema = z.string().regex(/^legacy:.+$/, "expected a `legacy:<source-id>` namespaced id");
+var canonicalTraceIdSchema = z.union([w3cTraceIdSchema, legacyIdSchema]);
+var canonicalSpanIdSchema = z.union([w3cSpanIdSchema, legacyIdSchema]);
+var otelSpanEventObjectSchema = z.object({
+  // ── shared event-union base (mirrors `eventBaseShape` in recorder-events.ts) ─
+  ts: z.string().datetime(),
+  event_id: canonicalSpanIdSchema,
+  // F-1200 — `parent_event_id` replaces `parent_id`. For THIS kind the field is
+  // fully redundant with `parent_span_id` (the invariant below pins them
+  // equal), so the tolerant read needs no `parent_id` lookup at all: a row
+  // written under either spelling normalizes to the same value, derived from
+  // span context. `parent_id` stays accepted as a legacy input key so a stored
+  // 0.13.0 row round-trips unchanged.
+  parent_event_id: canonicalSpanIdSchema.nullable().optional(),
+  parent_id: canonicalSpanIdSchema.nullable().optional(),
+  kind: z.literal("OtelSpanEvent"),
+  // ── W3C trace context — real span parentage (M3 correlation reads these) ────
+  trace_id: canonicalTraceIdSchema,
+  span_id: canonicalSpanIdSchema,
+  parent_span_id: canonicalSpanIdSchema.nullable(),
+  // ── span identity / timing / status ────────────────────────────────────────
+  name: z.string().min(1),
+  span_kind: otelSpanKindSchema,
+  start_time_unix_nano: unixNanoSchema,
+  end_time_unix_nano: unixNanoSchema.nullable(),
+  status_code: otelStatusCodeSchema,
+  status_message: z.string().nullable(),
+  // ── GenAI projections (flat; null when the span lacks the attribute) ────────
+  gen_ai_provider_name: z.string().nullable(),
+  gen_ai_operation_name: z.string().nullable(),
+  gen_ai_request_model: z.string().nullable(),
+  gen_ai_agent_name: z.string().nullable(),
+  gen_ai_agent_id: z.string().nullable(),
+  gen_ai_tool_name: z.string().nullable(),
+  gen_ai_usage_input_tokens: z.number().int().min(0).nullable(),
+  gen_ai_usage_output_tokens: z.number().int().min(0).nullable(),
+  // ── HTTP / core projections (flat; null when the span lacks the attribute) ──
+  http_request_method: z.string().nullable(),
+  http_response_status_code: z.number().int().nullable(),
+  url_full: z.string().nullable(),
+  url_path: z.string().nullable(),
+  server_address: z.string().nullable(),
+  server_port: z.number().int().min(0).nullable(),
+  error_type: z.string().nullable(),
+  // ── full, verbatim attribute bag (lossless; typed fields project from this) ─
+  attributes: z.record(z.string(), otelAttributeValueSchema)
+});
+var otelSpanEventSchema = otelSpanEventObjectSchema.transform((event) => ({
+  ...event,
+  parent_event_id: event.parent_event_id ?? event.parent_span_id
+})).superRefine((event, ctx) => {
+  if (event.event_id !== event.span_id) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["event_id"],
+      message: "event_id must equal span_id"
+    });
+  }
+  if (event.parent_event_id !== event.parent_span_id) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["parent_event_id"],
+      message: "parent_event_id must equal parent_span_id"
+    });
+  }
+  if (event.ts !== nanosToIso(event.start_time_unix_nano)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["ts"],
+      message: "ts must equal nanosToIso(start_time_unix_nano)"
+    });
+  }
+  if (event.end_time_unix_nano !== null && compareUint64(event.end_time_unix_nano, event.start_time_unix_nano) < 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["end_time_unix_nano"],
+      message: "end_time_unix_nano must be >= start_time_unix_nano"
+    });
+  }
+  const projected = projectAttributes(event.attributes);
+  for (const key of OTEL_PROJECTION_KEYS) {
+    if (event[key] !== projected[key]) {
+      ctx.addIssue({
+        code: "custom",
+        path: [key],
+        message: `${key} must equal projectAttributes(attributes).${key}`
+      });
+    }
+  }
+});
+z.object({
+  trace_id: w3cTraceIdSchema,
+  span_id: w3cSpanIdSchema,
+  parent_span_id: w3cSpanIdSchema.nullable().optional(),
+  name: z.string().min(1),
+  kind: z.union([otelSpanKindSchema, z.number().int().min(0).max(5)]).optional(),
+  start_time_unix_nano: unixNanoSchema,
+  end_time_unix_nano: unixNanoSchema.nullable().optional(),
+  status: z.object({
+    code: z.union([otelStatusCodeSchema, z.number().int().min(0).max(2)]).optional(),
+    message: z.string().nullable().optional()
+  }).optional(),
+  attributes: z.record(z.string(), otelAttributeValueSchema).default({})
+});
+z.discriminatedUnion("kind", [
+  twinHttpEventSchema,
+  llmCallEventSchema,
+  toolUseEventSchema
+]);
+z.union([eventSchema, otelSpanEventSchema]);
+
+export { eventSchema, isLegacyEventRow, twinIdSchema };