@smthrs/gateway 1.0.0-rc.4 → 1.0.0-rc.5

package/dist/cjs/GatewayProjection.d.ts

@@ -117,6 +117,7 @@ export declare const RunSummaryRow: Schema.Struct<{
     readonly finalOutput: Schema.optional<Schema.String>;
     /** The failed run's fault class and `<_tag>/<code>`, stamped when it failed. */
     readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+    readonly failureMessage: Schema.optional<Schema.String>;
     readonly failureTag: Schema.optional<Schema.String>;
 }>;
 /**

package/dist/cjs/GatewayProjection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GatewayProjection.d.ts","sourceRoot":"","sources":["../../src/GatewayProjection.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"GatewayProjection.d.ts","sourceRoot":"","sources":["../../src/GatewayProjection.ts"],"names":[],"mappings":"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"}

package/dist/cjs/GatewayProjection.js

@@ -93,6 +93,7 @@ const RunSummaryRow = import_effect.Schema.Struct({
   finalOutput: import_effect.Schema.optional(import_effect.Schema.String),
   /** The failed run's fault class and `<_tag>/<code>`, stamped when it failed. */
   failureFault: import_effect.Schema.optional(Fault.Class),
+  failureMessage: import_effect.Schema.optional(import_effect.Schema.String),
   failureTag: import_effect.Schema.optional(import_effect.Schema.String)
 });
 const RunTreeRow = import_effect.Schema.Struct({
@@ -201,7 +202,8 @@ const runSummary = (run, events, now = Math.max(run.updatedAt, events.at(-1)?.oc
       Diagnosis.resolvedOutput(facts) ?? (run.status === "failed" && facts.fault?.tag.endsWith("/source_refused") && facts.cause?.match(/source_refused: ([a-z_]+)/) ? JSON.stringify({ message: facts.cause.match(/source_refused: ([a-z_]+)/)[0] }) : void 0)
     ),
     ...run.status === "failed" ? optional("failureFault", facts.fault?.class) : {},
-    ...run.status === "failed" ? optional("failureTag", facts.fault?.tag) : {}
+    ...run.status === "failed" ? optional("failureTag", facts.fault?.tag) : {},
+    ...run.status === "failed" ? optional("failureMessage", facts.cause) : {}
   };
 };
 const takeOpenCall = (open, callId, flowName, scope) => {

package/dist/cjs/GatewayProjection.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/GatewayProjection.ts"],
-  "sourcesContent": ["/**\n * The stable wire rows the gateway serves for each projection, and the pure\n * folds that compute them from control-plane facts.\n *\n * These rows are the whole read contract. Nothing here exposes a store row, a\n * database column, or an engine type: every field is either a\n * `@smthrs/control` projection value or something folded out of the ordered\n * `ControlEvent` deltas `Control.watch` publishes. Wire names are the flows\n * names (`flowId`, `createdAt`, and the `ApprovalTarget.Node` envelope), so a\n * client written against the control plane reads these rows without a\n * translation table.\n *\n * @since 1.0.0\n */\n\nimport { ControlFacts, ControlSchema, Health, Monitor } from \"@smthrs/control\"\nimport * as Fault from \"@smthrs/flow/Fault\"\nimport { ExecutionFact } from \"@smthrs/journal\"\nimport { Schema } from \"effect\"\nimport * as Diagnosis from \"./Diagnosis.ts\"\nimport { callScope, openCallIndex, uniqueCallEvents } from \"./internal/callEvents.ts\"\nimport * as NativeResolution from \"./internal/nativeResolution.ts\"\nimport * as NodeEvents from \"./internal/nodeEvents.ts\"\n\n/**\n * One run, everything a run card displays, and the diagnosis of what happened\n * to it.\n *\n * `flowId` carries what the old wire split across `run.workflowKey` and\n * `run.workflow`, and `createdAt` carries `run.createdAtMs`: one flows name\n * each, rather than two spellings of one fact.\n *\n * @since 1.0.0\n * @category models\n */\nexport const RunSummaryRow = Schema.Struct({\n  runId: Schema.String,\n  flowId: Schema.String,\n  statusRollup: Schema.optional(Health.StatusRollup),\n  status: ControlSchema.RunStatus,\n  lifecycleProvenance: Schema.optional(ControlFacts.LifecycleProvenance),\n  executionProvenance: Schema.optional(ExecutionFact.Provenance),\n  createdAt: Schema.Number,\n  updatedAt: Schema.Number,\n  planId: Schema.optional(Schema.String),\n  planDigest: Schema.optional(Schema.String),\n  parentRunId: Schema.optional(Schema.String),\n  lineageId: Schema.optional(Schema.String),\n  roundOrdinal: Schema.optional(Schema.Number),\n  waitingReason: Schema.optional(Schema.String),\n  steeringPending: Schema.optional(Schema.Number),\n  cancellation: Schema.optional(ControlSchema.Cancellation),\n  /** When the run's approved deadline passes; absent for a run with none. */\n  deadlineAt: Schema.optional(Schema.Number),\n  /** The model seat the run's last opened turn ran on. */\n  seat: Schema.optional(Schema.String),\n  turns: Schema.Number,\n  calls: Schema.Number,\n  callsFailed: Schema.Number,\n  editsAttempted: Schema.Number,\n  editsSucceeded: Schema.Number,\n  inputTokens: Schema.Number,\n  outputTokens: Schema.Number,\n  /**\n   * One line: the run row's status plus the reason that most explains it.\n   *\n   * Lifecycle provenance distinguishes a covered control fact from a legacy\n   * snapshot or a separate engine observation. Missing facts never silently\n   * replace a newer observed state with the last recorded status.\n   */\n  verdict: Schema.String,\n  /** The whole diagnosis card, which the old wire called `whatHappened`. */\n  diagnosis: Schema.String,\n  finalOutput: Schema.optional(Schema.String),\n  /** The failed run's fault class and `<_tag>/<code>`, stamped when it failed. */\n  failureFault: Schema.optional(Fault.Class),\n  failureTag: Schema.optional(Schema.String)\n})\n\n/**\n * One run, everything a run card displays, and its diagnosis.\n *\n * @since 1.0.0\n * @category models\n */\nexport type RunSummaryRow = typeof RunSummaryRow.Type\n\n/**\n * One node of a run, as a tree view renders it.\n *\n * `label` carries what the old wire called `node.cardLabel`, and `seat`\n * carries `node.agent`: the model seat is the flows name for who ran a node.\n *\n * `nodeId` is the ordinal the call opened on, because the emitter names no\n * node. {@link runTree} says why.\n *\n * @since 1.0.0\n * @category models\n */\nexport const RunTreeRow = Schema.Struct({\n  runId: Schema.String,\n  nodeId: Schema.String,\n  label: Schema.String,\n  status: Schema.Literals([\"running\", \"completed\", \"failed\"]),\n  seat: Schema.optional(Schema.String),\n  startedAt: Schema.Number,\n  endedAt: Schema.optional(Schema.Number),\n  parentRunId: Schema.optional(Schema.String)\n})\n\n/**\n * One node of a run, as a tree view renders it.\n *\n * @since 1.0.0\n * @category models\n */\nexport type RunTreeRow = typeof RunTreeRow.Type\n\n/**\n * One approval a run is parked on, carrying the exact payload that decides it.\n *\n * `title` carries the old `approval.requestTitle` and `request` the old\n * `approval.request`; `payload` is the `ApprovalTarget.Node` envelope a client\n * submits back unchanged, so no client reconstructs authority.\n *\n * @since 1.0.0\n * @category models\n */\nexport const ApprovalRow = Schema.Struct({\n  runId: Schema.String,\n  /**\n   * The execution holding the wait, when this gate is a question a person owes\n   * an answer to and it is held below `runId`.\n   *\n   * `runId` is the run a person opened and the run a decision is addressed to;\n   * a `HumanTask` in a nested flow parks its own execution, and the two are\n   * different runs. Present only on such a gate, so a reader can tell a\n   * question rolled up from a tree from one the named run raised itself, and\n   * an inbox can list one question once however many ancestors carry it.\n   */\n  waitRunId: Schema.optional(Schema.String),\n  questionProvenance: Schema.optional(Schema.Literals([\"events\", \"legacy-observation\", \"unverified-observation\"])),\n  requestId: Schema.String,\n  title: Schema.String,\n  request: Schema.Json,\n  payload: ControlSchema.ApprovalPayload,\n  requestedAt: Schema.Number,\n  status: Schema.Literals([\"pending\", \"approved\", \"denied\"])\n})\n\n/**\n * One approval a run is parked on.\n *\n * @since 1.0.0\n * @category models\n */\nexport type ApprovalRow = typeof ApprovalRow.Type\n\n/**\n * The output one node produced.\n *\n * @since 1.0.0\n * @category models\n */\nexport const NodeOutputRow = Schema.Struct({\n  runId: Schema.String,\n  nodeId: Schema.String,\n  outcome: Schema.Literals([\"success\", \"failure\"]),\n  output: Schema.String,\n  settledAt: Schema.Number\n})\n\n/**\n * The output one node produced.\n *\n * @since 1.0.0\n * @category models\n */\nexport type NodeOutputRow = typeof NodeOutputRow.Type\n\n/**\n * How long one flow's nodes take, per action tag.\n *\n * `samples` is the number of measured executions behind the two percentiles,\n * and it is on the wire because a percentile over one sample and a percentile\n * over twenty are different claims. A tag with no measured execution has no\n * row at all: there is no shape here for an unmeasured prediction.\n *\n * @since 1.0.0\n * @category models\n */\nexport const FlowDurationRow = Schema.Struct({\n  flowId: Schema.String,\n  actionTag: Schema.String,\n  samples: Schema.Number,\n  p50Ms: Schema.Number,\n  p90Ms: Schema.Number\n})\n\n/**\n * How long one flow's nodes take, per action tag.\n *\n * @since 1.0.0\n * @category models\n */\nexport type FlowDurationRow = typeof FlowDurationRow.Type\n\n/**\n * One measured execution of one node, as a duration fold's sample.\n *\n * The action tag is the only part of a node's key material that survives a\n * re-key, which is why history is grouped by it rather than by node id or by\n * dispatch key.\n *\n * @since 1.0.0\n * @category models\n */\nexport interface NodeDuration {\n  readonly actionTag: string\n  readonly durationMs: number\n}\n\n/**\n * One line of a run's turn-by-turn transcript.\n *\n * @since 1.0.0\n * @category models\n */\nexport const TranscriptRow = Schema.Struct({\n  runId: Schema.String,\n  sequence: Schema.Number,\n  turn: Schema.Number,\n  at: Schema.Number,\n  kind: Schema.String,\n  /** Dispatch identity on current call records; absent on legacy history. */\n  callId: Schema.optional(Schema.String),\n  text: Schema.String\n})\n\n/**\n * One line of a run's turn-by-turn transcript.\n *\n * @since 1.0.0\n * @category models\n */\nexport type TranscriptRow = typeof TranscriptRow.Type\n\n/** Copies only the optional fields a run summary actually carries. */\nconst optional = <A>(key: string, value: A | undefined): Record<string, A> =>\n  value === undefined ? {} : { [key]: value }\n\n/**\n * Folds one run's summary and events into the served `run-summary` row.\n *\n * @param run the control-plane run summary\n * @param events that run's ordered control events\n * @param now the instant the row is rendered at\n * @param carry the digest of the events a bounded reader dropped before them\n * @since 1.0.0\n * @category projections\n */\nexport const runSummary = (\n  run: ControlSchema.RunSummary,\n  events: ReadonlyArray<ControlSchema.ControlEvent>,\n  now: number = Math.max(run.updatedAt, events.at(-1)?.occurredAt ?? 0),\n  carry?: Diagnosis.Digest | undefined\n): RunSummaryRow => {\n  const projected = ControlFacts.fold(events, run)\n  // Supplying a snapshot guarantees a run: uncovered facts retain that\n  // observation; only the event-only fold can return an absent run.\n  run = projected.run!\n  const native = ExecutionFact.foldControl(events, run.runId, run.executionView)\n  // The control fold remains control authority. Native lifecycle is independently\n  // replayed/verified against the coherent executor observation when available.\n  if (run.executionObservation === \"observed\" && native?.view !== undefined) {\n    const { root, current } = native.view\n    run = {\n      ...run,\n      status: current.status === \"pending\" ? \"accepted\" : current.status === \"suspended\"\n        ? current.waiting?.reason === \"approval\" ||\n            (native.view.humanWaits?.length ?? run.pendingWaits?.length ?? 0) > 0\n          ? \"waiting-approval\" :\n          \"parked\"\n        : current.status === \"running\" && (native.view.humanWaits?.length ?? run.pendingWaits?.length ?? 0) > 0\n        ? \"waiting-approval\" :\n        current.status,\n      waitingReason: current.status === \"suspended\" ? current.waiting?.reason : undefined,\n      parentRunId: root.parentRunId ?? undefined,\n      lineageId: root.lineageId,\n      roundOrdinal: root.roundOrdinal\n    }\n  }\n  // `carry` is the digest of the events a bounded reader dropped ahead of\n  // `events`. Combining it keeps turns, calls, edits and tokens exact for a run\n  // whose journal no longer fits one window, so the counters a run card shows\n  // describe the whole run and not just its tail.\n  const window = Diagnosis.digest(events, run.runId)\n  const facts = { ...(carry === undefined ? window : Diagnosis.combine(carry, window)), status: run.status }\n  return {\n    runId: run.runId,\n    flowId: run.flowId,\n    status: run.status,\n    lifecycleProvenance: projected.provenance,\n    ...optional(\"executionProvenance\", native?.provenance),\n    statusRollup: statusRollup(run, events, now),\n    createdAt: run.createdAt,\n    updatedAt: run.updatedAt,\n    ...optional(\"planId\", run.planId),\n    ...optional(\"planDigest\", run.planDigest),\n    ...optional(\"parentRunId\", run.parentRunId),\n    ...optional(\"lineageId\", run.lineageId),\n    ...optional(\"roundOrdinal\", run.roundOrdinal),\n    ...optional(\"waitingReason\", run.waitingReason),\n    ...optional(\"steeringPending\", run.steering?.pending),\n    ...optional(\"cancellation\", run.cancellation),\n    ...optional(\"deadlineAt\", run.deadlineAt),\n    ...optional(\"seat\", facts.seat),\n    turns: facts.turns,\n    calls: facts.calls,\n    callsFailed: facts.callsFailed,\n    editsAttempted: facts.editsAttempted,\n    editsSucceeded: facts.editsSucceeded,\n    inputTokens: facts.inputTokens,\n    outputTokens: facts.outputTokens,\n    verdict: Diagnosis.verdict(facts),\n    diagnosis: Diagnosis.render({ runId: run.runId, ...optional(\"flowId\", run.flowId) }, facts),\n    ...optional(\n      \"finalOutput\",\n      Diagnosis.resolvedOutput(facts) ?? (\n        run.status === \"failed\" && facts.fault?.tag.endsWith(\"/source_refused\") &&\n          facts.cause?.match(/source_refused: ([a-z_]+)/)\n          ? JSON.stringify({ message: facts.cause.match(/source_refused: ([a-z_]+)/)![0] })\n          : undefined\n      )\n    ),\n    ...(run.status === \"failed\" ? optional(\"failureFault\", facts.fault?.class) : {}),\n    ...(run.status === \"failed\" ? optional(\"failureTag\", facts.fault?.tag) : {})\n  }\n}\n\n/**\n * Claims a call by its durable dispatch identity. Legacy history has no id:\n * match only legacy starts by flow name (or FIFO when unnamed). A new\n * settlement can close a legacy start after an old parked run resumes, but\n * neither fallback may steal an identified call.\n */\nconst takeOpenCall = <\n  A extends { readonly flowName: string; readonly callId: string | undefined; readonly scope: string | undefined }\n>(\n  open: Array<A>,\n  callId: string | undefined,\n  flowName: string | undefined,\n  scope: string | undefined\n): A | undefined => {\n  const found = openCallIndex(open, callId, flowName, scope)\n  return found < 0 ? undefined : open.splice(found, 1)[0]\n}\n\n/**\n * One agent call, as every node projection sees it: the ordinal it opened on,\n * the seat that ran it, and the settlement that closed it, if one did.\n */\ninterface CallRecord {\n  readonly nodeId: string\n  readonly flowName: string\n  readonly seat: string | undefined\n  readonly startedAt: number\n  readonly settlement: CallSettlement | undefined\n}\n\n/** What closed a call, and where among the run's settlements it closed. */\ninterface CallSettlement {\n  /** The rank of this settlement among the run's, counting from one. */\n  readonly order: number\n  /** The run the settlement named, which a malformed journal can omit. */\n  readonly runId: string | undefined\n  readonly at: number\n  readonly outcome: \"success\" | \"failure\"\n  readonly output: string\n}\n\n/**\n * Folds one run's events into the agent calls it made, in the order they\n * opened.\n *\n * This is the only fold that assigns a call its `call-N` identity, records the\n * seat and time it opened on, and pairs a settlement with the call it closed.\n * A client asks for a node's output by the id a tree row carries, so the two\n * projections have to agree on that id; when they counted separately they\n * could disagree, and once did, because skipping an event before the ordinal\n * advanced shifted one fold's keys against the other's. The ordinal therefore\n * advances on every distinct start, whatever else that event is missing.\n * Identified duplicate starts and settlements are ignored. Old idless rows\n * retain their original ordinal/FIFO interpretation; their missing dispatch\n * identity cannot be reconstructed when same-name calls overlapped.\n *\n * `uniqueCallEvents` also normalizes native step facts, so this fold reads the\n * run's own records and one stream per step a module run dispatched. The three\n * classes `Diagnosis` names apply here too, field by field:\n *\n * | Field                   | Class           | Why                                                    |\n * | ----------------------- | --------------- | ------------------------------------------------------ |\n * | `nodeId` (`call-N`)     | aggregate       | one tree lists every call the run made, steps included |\n * | `flowName`, `startedAt` | aggregate       | read off the call's own record                         |\n * | `settlement`            | aggregate       | claimed by call identity within the recorded scope     |\n * | `seat`                  | scope dependent | who ran THIS call, so the turn must be this call's own |\n *\n * There is no root-only field here: a tree row describes a call, never the\n * run's answer or state. A new field has to name its class.\n */\nconst callHistory = (\n  events: ReadonlyArray<ControlSchema.ControlEvent>\n): ReadonlyArray<CallRecord> => {\n  const calls = new Map<string, CallRecord>()\n  const open: Array<\n    {\n      readonly callId: string | undefined\n      readonly flowName: string\n      readonly call: CallRecord\n      readonly scope: string | undefined\n    }\n  > = []\n  // The seat of the last turn opened in each scope. A module run interleaves\n  // steps in one journal, so the run-wide reading attributed one step's seat\n  // to another step's calls. A prompt run records one unscoped stream and\n  // reads exactly as it did.\n  const seats = new Map<string | undefined, string | undefined>()\n  let ordinal = 0\n  let settlements = 0\n\n  for (const event of uniqueCallEvents(events)) {\n    const payload = Diagnosis.asRecord(event.payload)\n    if (event.kind === \"control.agent.turn-opened\") {\n      const scope = callScope(event)\n      seats.set(scope, Diagnosis.asString(payload.seat) ?? seats.get(scope))\n      continue\n    }\n    if (event.kind === \"control.agent.cell-call-started\") {\n      const callId = Diagnosis.asString(payload.callId)\n      ordinal += 1\n      const nodeId = `call-${ordinal}`\n      const flowName = Diagnosis.asString(payload.flowName) ?? nodeId\n      const scope = callScope(event)\n      // This scope's own turn, else the run's. A step that opened no turn of\n      // its own borrows nothing from a sibling step.\n      const seat = seats.get(scope) ?? seats.get(undefined)\n      const call: CallRecord = { nodeId, flowName, seat, startedAt: Diagnosis.timeOf(event), settlement: undefined }\n      open.push({ callId, flowName, call, scope })\n      calls.set(nodeId, call)\n      continue\n    }\n    if (event.kind !== \"control.agent.cell-call-settled\") continue\n    const callId = Diagnosis.asString(payload.callId)\n    const claimed = takeOpenCall(open, callId, Diagnosis.asString(payload.flowName), callScope(event))\n    if (claimed === undefined) continue\n    const failed = Diagnosis.asString(payload.outcome) === \"failure\"\n    settlements += 1\n    // Rewriting the entry keeps the call in the position it opened on, which\n    // is the order a tree renders.\n    calls.set(claimed.call.nodeId, {\n      ...claimed.call,\n      settlement: {\n        order: settlements,\n        runId: Diagnosis.asString(payload.runId) ?? event.runId,\n        at: Diagnosis.timeOf(event),\n        outcome: failed ? \"failure\" : \"success\",\n        output: failed\n          ? Diagnosis.asString(payload.message) ?? \"\"\n          : Diagnosis.asString(payload.value) ?? JSON.stringify(payload.value ?? null)\n      }\n    })\n  }\n  return [...calls.values()]\n}\n\n/** How a tree row reports a call: settled the way it settled, or still running. */\nconst treeStatus = (settlement: CallSettlement | undefined): RunTreeRow[\"status\"] => {\n  if (settlement === undefined) return \"running\"\n  return settlement.outcome === \"failure\" ? \"failed\" : \"completed\"\n}\n\n/**\n * Folds one run's events into its node rows.\n *\n * A node opens on `control.agent.cell-call-started` and settles on the\n * matching `control.agent.cell-call-settled`.\n *\n * AgentSession journals the same `callId` from the harness's dispatch identity\n * on both records. Settlements join on it even when same-name calls overlap\n * and finish out of order. The distinct-start ordinal remains the published\n * `call-N` node key, preserving existing node links. Legacy records without\n * callId retain same-name FIFO pairing, restricted to other legacy records\n * (including a newly identified settlement of an old parked call).\n *\n * The durable engine's own `flows.engine.*` records are not folded here, but\n * that is a choice rather than a limit. A host keeps the control plane and the\n * engine in two databases with two journals (`@smthrs/cli`\n * `NodeControl.databasePath` and `executionDatabasePath`), and\n * `EngineJournalProjection` copies every engine entry of the run into the\n * control journal as a `control.engine.event` envelope, which is how\n * {@link nodeDurations} reads the node records. A tree row is an agent cell\n * call, so what an engine step did reaches this projection as the call that\n * made it.\n *\n * A node that never settled stays `running`, which is how a live tree renders\n * work in flight.\n *\n * @param run the control-plane run summary\n * @param events that run's ordered control events\n * @since 1.0.0\n * @category projections\n */\nexport const runTree = (\n  run: ControlSchema.RunSummary,\n  events: ReadonlyArray<ControlSchema.ControlEvent>\n): ReadonlyArray<RunTreeRow> =>\n  callHistory(events).map((call): RunTreeRow => ({\n    runId: run.runId,\n    nodeId: call.nodeId,\n    label: call.flowName,\n    status: treeStatus(call.settlement),\n    ...optional(\"seat\", call.seat),\n    startedAt: call.startedAt,\n    ...optional(\"endedAt\", call.settlement?.at),\n    ...optional(\"parentRunId\", run.parentRunId)\n  }))\n\n/**\n * The declared question of a human wait, as far as it can be read.\n *\n * `request` is whatever the wait wrote about itself, which for `HumanTask` is\n * `{task, name, kind, prompt, attempt, maxAttempts}`. A wait that declared\n * nothing \u2014 an older park, or a plugin's own \u2014 still produces a row, because a\n * gate a person cannot see is a run that waits forever; it just has less to\n * render.\n */\nconst questionOf = (wait: ControlSchema.PendingWait): Record<string, unknown> => Diagnosis.asRecord(wait.request)\n\n/**\n * One pending row for a human wait held anywhere in a run's tree.\n *\n * `runId` is the ROOT: this is the run a person opened, and the run a decision\n * is addressed to. `waitRunId` is the execution actually holding it, because a\n * client routes by run and the control plane routes within the tree.\n *\n * `requestId` is the wait point's own name (`coding-clarification#1`), which is\n * unique within a tree, stable across a re-read, and the name a `Signal`\n * addresses. The token travels in the request too, for a client that would\n * rather submit the exact durable address back.\n */\nconst humanWaitRow = (\n  run: ControlSchema.RunSummary,\n  wait: ControlSchema.PendingWait,\n  projected?: ExecutionFact.Observation,\n  questionProvenance: \"events\" | \"legacy-observation\" | \"unverified-observation\" = \"legacy-observation\"\n): ApprovalRow => {\n  const question = projected === undefined ? questionOf(wait) : Diagnosis.asRecord(projected.waiting?.request)\n  const name = wait.name ?? Diagnosis.asString(question[\"name\"]) ?? wait.token\n  const requestId = wait.attempt === undefined ? name : `${name}#${wait.attempt}`\n  const prompt = Diagnosis.asString(question[\"prompt\"])\n  const waitFlowId = projected?.flowName ?? wait.flowId\n  return {\n    runId: run.runId,\n    waitRunId: wait.runId,\n    questionProvenance,\n    requestId,\n    title: prompt ?? `Answer needed \u2014 ${name}`,\n    request: {\n      ...question,\n      kind: Diagnosis.asString(question[\"kind\"]) ?? \"ask\",\n      name,\n      ...(wait.attempt === undefined ? {} : { attempt: wait.attempt }),\n      ...(waitFlowId === undefined ? {} : { waitFlowId }),\n      token: wait.token\n    },\n    payload: {\n      target: {\n        _tag: \"Node\",\n        runId: run.runId,\n        requestId,\n        digest: wait.token,\n        // A human answer grants no capabilities: the envelope a decision binds\n        // to is the empty one, the same shape a flow with none carries.\n        envelope: { capabilities: [], flows: [], budget: {} }\n      },\n      scope: \"once\",\n      // The identity is the PARK, not its name: a loop that re-asks one\n      // question parks again under the same run, name and attempt, and a\n      // name-keyed answer would deduplicate the second decision into the\n      // first \u2014 accepted, never delivered, and parked forever.\n      idempotencyKey: `answer:${run.runId}:${requestId}:${wait.tokenDigest ?? wait.token}`\n    },\n    requestedAt: projected?.createdAtMs ?? wait.createdAt,\n    status: \"pending\"\n  }\n}\n\n/**\n * Folds one run's events into its approval rows.\n *\n * A request opens a pending row carrying the submit-ready payload; the\n * matching `control.approval.approved` or `control.approval.denied` closes it\n * without discarding the request, so a decided gate stays readable.\n *\n * A `HumanTask` declares its question on the parked row. Native execution\n * facts carry the redacted question and token digest; verified facts supply\n * its display metadata here. `@smthrs/control` rolls current open waits onto\n * the root as `pendingWaits`, which supply each row's protected wake address.\n * History alone cannot create an answerable human wait. Older observations\n * remain visible with explicit question provenance when native fact coverage\n * is unavailable. These rows come first because they still need an answer.\n *\n * A decision names the gate it closed by `tokenId`. `@smthrs/control`\n * `SqlControlRuntime.lookupApproval` mints that token id from the target, and\n * for the `Node` target a run parks on it is the request id itself, so the two\n * records join on one field. A decision whose `tokenId` or `requestId` names\n * no row is retained for an exact later request. Only a legacy decision that\n * names neither field closes the oldest pending legacy row in that run.\n * Current facts bind the target digest; duplicates cannot reopen a decision.\n *\n * @param events the run's ordered control events\n * @since 1.0.0\n * @category projections\n */\nexport const approvals = (\n  events: ReadonlyArray<ControlSchema.ControlEvent>,\n  run?: ControlSchema.RunSummary | undefined\n): ReadonlyArray<ApprovalRow> => {\n  const native = run === undefined ? undefined : ExecutionFact.foldControl(events, run.runId, run.executionView)\n  const grantFacts = events.filter((event) =>\n    event.kind === \"control.approval.requested\" && Schema.is(ControlFacts.ApprovalRequestFact)(event.payload)\n  )\n  const grants = ControlFacts.fold(grantFacts).approvals\n  const observed = run?.pendingWaits?.map((wait) => {\n    // An agent ask parks on its registered grant token, not a HumanTask answer.\n    // Preserve the committed target instead of inventing an answer-only target.\n    const grant = grants.find((row) => row.runId === run.runId && row.requestId === wait.token)\n    if (grant !== undefined) return grant\n    const projected = native?.provenance.humanWaits === \"events\" ?\n      native.view?.humanWaits?.find((candidate) =>\n        candidate.executionId === wait.runId && candidate.waiting?.tokenDigest === wait.tokenDigest\n      ) :\n      undefined\n    return humanWaitRow(\n      run,\n      wait,\n      projected,\n      projected === undefined\n        ? native?.provenance.humanWaits === \"events\" ?\n          \"unverified-observation\" :\n          native?.provenance.humanWaits ?? \"legacy-observation\"\n        : \"events\"\n    )\n  })\n  // The current observation supplies wake authority. History supplies only the\n  // display metadata that verifies against that exact observed token digest.\n  return ControlFacts.fold(events, undefined, observed).approvals\n}\n\n/**\n * Folds one run's events into its node outputs, keyed the way {@link runTree}\n * keys its rows: by the ordinal the call opened on.\n *\n * A settled call carries the value it produced, so the row carries that value.\n * A run's own result reaches a client as `RunSummaryRow.finalOutput` instead.\n *\n * @param events the run's ordered control events\n * @since 1.0.0\n * @category projections\n */\nexport const nodeOutput = (\n  events: ReadonlyArray<ControlSchema.ControlEvent>\n): ReadonlyArray<NodeOutputRow> => {\n  const settled: Array<{ readonly order: number; readonly row: NodeOutputRow }> = []\n  for (const call of callHistory(events)) {\n    const settlement = call.settlement\n    if (settlement === undefined) continue\n    // A row names the run it belongs to. A settlement that names none closes\n    // its call without producing one.\n    if (settlement.runId === undefined) continue\n    settled.push({\n      order: settlement.order,\n      row: {\n        runId: settlement.runId,\n        nodeId: call.nodeId,\n        outcome: settlement.outcome,\n        output: settlement.output,\n        settledAt: settlement.at\n      }\n    })\n  }\n  // A tree reads in the order calls opened; outputs read in the order they\n  // settled, which is the order a client watched them arrive.\n  return settled.sort((left, right) => left.order - right.order).map((entry) => entry.row)\n}\n\n/** The node id every execution gives the flow it was started to run. */\nconst rootNodeId = \"root\"\n\n/**\n * The native execution the host bound this control run to, when one is known.\n *\n * Only the host's own binding record names the root, and two records that\n * disagree name nothing: an ambiguous binding cannot tell a callee's\n * execution apart from the root's, so it authorizes no skip.\n *\n * The binding is written once, when the host takes the root up, so a window\n * bounded to a run's newest events is the one window it falls out of. The\n * carried digest keeps it across that eviction, and reading from the carry is\n * what keeps a long run's calls counted the same as a short run's.\n */\nconst boundExecution = (\n  events: ReadonlyArray<ControlSchema.ControlEvent>,\n  carry: Diagnosis.Digest | undefined\n): string | undefined => {\n  let resolution = carry?.nativeResolution\n  for (const event of events) resolution = NativeResolution.combine(resolution, NativeResolution.fromEvent(event))\n  return resolution === undefined || resolution.conflict === true ? undefined : resolution.binding?.executionId\n}\n\n/**\n * A callee's own view of a call its caller already measured.\n *\n * Every execution below the bound root was started by a `FlowCall` node in\n * the execution above it, and that node carries the same action tag over the\n * same span. The caller's node is the one kept, because it is the node a plan\n * carries and the one a graph can join a prediction onto.\n *\n * With no binding nothing is echoed: a fold that cannot name the root cannot\n * tell which `root` record belongs to it, and dropping samples on a guess\n * would answer a smaller history than the flow ran.\n */\nconst echoedRoot = (bound: string | undefined, executionId: string, nodeId: string): boolean =>\n  bound !== undefined && nodeId === rootNodeId && executionId !== bound\n\n/**\n * Folds one run's events into the executions it measured.\n *\n * A node's work starts when the engine recorded it scheduled and ends when it\n * recorded it settled, so a duration is the distance between those two native\n * stamps. Four of the five outcomes contribute nothing: `clean` was served\n * from records rather than run, `failed` measures a collapse, `skipped` was\n * never reached, and `deferred` is scheduling debt. Only `built` ran.\n *\n * A settlement pairs with the LAST schedule of the same execution and node,\n * which is what makes a retried node measure its final attempt rather than\n * the span across every attempt. Two executions of one node id stay apart\n * because the pairing key carries the execution, and a settlement no schedule\n * opened measures nothing rather than measuring from zero.\n *\n * A record that names no action tag contributes nothing either: history is\n * grouped by tag, and a sample with no tag has nowhere honest to go.\n *\n * A called flow is measured once. The engine records one call twice: the\n * caller admits and settles the node that made it, and the callee's own\n * execution admits and settles its `root` over the same span with the same\n * action tag. {@link echoedRoot} drops the callee's copy, so one invocation\n * is one sample rather than two, and `samples` stays the count of executions\n * the flow performed.\n *\n * @param events the run's ordered control events\n * @param carry the digest of the events a bounded window dropped, when it dropped any\n * @since 1.0.0\n * @category projections\n */\nexport const nodeDurations = (\n  events: ReadonlyArray<ControlSchema.ControlEvent>,\n  carry?: Diagnosis.Digest | undefined\n): ReadonlyArray<NodeDuration> => {\n  const bound = boundExecution(events, carry)\n  const started = new Map<string, number>()\n  const measured: Array<NodeDuration> = []\n  for (const event of events) {\n    const schedule = NodeEvents.nodeScheduled(event)\n    if (schedule !== undefined) {\n      if (echoedRoot(bound, schedule.executionId, schedule.payload.nodeId)) continue\n      started.set(`${schedule.executionId}\\u0000${schedule.payload.nodeId}`, schedule.emittedAtMs)\n      continue\n    }\n    const settlement = NodeEvents.nodeSettled(event)\n    if (settlement === undefined) continue\n    if (echoedRoot(bound, settlement.executionId, settlement.payload.nodeId)) continue\n    if (settlement.payload.outcome !== \"built\") continue\n    const actionTag = settlement.payload.action\n    if (actionTag === undefined) continue\n    const key = `${settlement.executionId}\\u0000${settlement.payload.nodeId}`\n    const startedAt = started.get(key)\n    if (startedAt === undefined) continue\n    started.delete(key)\n    const durationMs = settlement.emittedAtMs - startedAt\n    // Wall clocks can move backwards, and a completion that predates its own\n    // start is a clock fact rather than a duration.\n    if (durationMs < 0) continue\n    measured.push({ actionTag, durationMs })\n  }\n  return measured\n}\n\n/** The nearest-rank percentile of an ascending sample, which is one observed value. */\nconst nearestRank = (ascending: ReadonlyArray<number>, percentile: number): number =>\n  ascending[Math.ceil((percentile / 100) * ascending.length) - 1]!\n\n/**\n * Folds every measured execution of one flow into one row per action tag.\n *\n * Both percentiles are nearest-rank, so each answer is a duration the flow\n * really took rather than an interpolation between two it did not. Rows are\n * ordered by tag, so two reads of the same history answer in the same order.\n *\n * A tag reaches this function only by having been measured, so every row\n * carries at least one sample, and a flow nothing has measured answers with\n * no rows at all.\n *\n * @param flowId the flow whose history was read\n * @param samples every measured execution of that flow's runs\n * @since 1.0.0\n * @category projections\n */\nexport const flowDurations = (\n  flowId: string,\n  samples: ReadonlyArray<NodeDuration>\n): ReadonlyArray<FlowDurationRow> => {\n  const byTag = new Map<string, Array<number>>()\n  for (const sample of samples) {\n    const held = byTag.get(sample.actionTag)\n    if (held === undefined) byTag.set(sample.actionTag, [sample.durationMs])\n    else held.push(sample.durationMs)\n  }\n  return [...byTag.entries()]\n    .sort(([left], [right]) => left < right ? -1 : 1)\n    .map(([actionTag, observed]) => {\n      const ascending = [...observed].sort((left, right) => left - right)\n      return {\n        flowId,\n        actionTag,\n        samples: ascending.length,\n        p50Ms: nearestRank(ascending, 50),\n        p90Ms: nearestRank(ascending, 90)\n      }\n    })\n}\n\n/** Events the transcript reports verbatim rather than as agent activity. */\nconst transcriptKinds: ReadonlySet<string> = new Set([\"control.approval.requested\"])\n\n/**\n * Folds one run's events into a turn-numbered transcript.\n *\n * A row is reported for every `control.run.*` and `control.agent.*` event and\n * for an approval request, and for nothing else: the transcript is what a\n * reader follows, not the whole journal, which `run-events` already serves.\n * The turn counter advances on `control.agent.turn-opened`, so every row\n * carries the turn it belongs to, and each row's text is one display line, so\n * a multi-line seat, message, or question cannot split one row into several.\n *\n * `uniqueCallEvents` normalizes native step facts, so a module run's steps\n * report here too. The classes `Diagnosis` names apply, field by field:\n *\n * | Field  | Class     | Why                                                       |\n * | ------ | --------- | --------------------------------------------------------- |\n * | rows   | aggregate | every row is one event this run recorded, wherever it ran |\n * | `turn` | aggregate | a turn a step opened is a turn this run opened            |\n *\n * No row is root only, because no row claims to be the run's answer or state:\n * a `control.agent.resolved` row says one agent resolved, and the run's own\n * answer is served by `runSummary` from `Diagnosis`. A new field has to name\n * its class.\n *\n * @param events the run's ordered control events\n * @since 1.0.0\n * @category projections\n */\nexport const transcript = (\n  events: ReadonlyArray<ControlSchema.ControlEvent>\n): ReadonlyArray<TranscriptRow> => {\n  const rows: Array<TranscriptRow> = []\n  let turn = 0\n  for (const event of uniqueCallEvents(events)) {\n    const payload = Diagnosis.asRecord(event.payload)\n    const runId = Diagnosis.asString(payload.runId) ?? event.runId\n    if (runId === undefined) continue\n    const reported = event.kind.startsWith(\"control.run.\") ||\n      event.kind.startsWith(\"control.agent.\") ||\n      transcriptKinds.has(event.kind)\n    if (!reported) continue\n    if (event.kind === \"control.agent.turn-opened\") turn += 1\n    rows.push({\n      runId,\n      sequence: event.sequence,\n      turn,\n      at: Diagnosis.timeOf(event),\n      kind: event.kind,\n      ...optional(\"callId\", Diagnosis.asString(payload.callId)),\n      text: line(event.kind, payload)\n    })\n  }\n  return rows\n}\n\n/** One event as a single transcript line. */\nconst line = (kind: string, payload: Record<string, unknown>): string => {\n  switch (kind) {\n    case \"control.agent.turn-opened\":\n      return `turn opened \u00B7 ${Diagnosis.firstLine(Diagnosis.asString(payload.seat) ?? \"\")}`\n    case \"control.agent.model-settled\": {\n      const usage = Diagnosis.asRecord(payload.usage)\n      return `model ${Diagnosis.asNumber(usage.inputTokens) ?? 0} in / ${\n        Diagnosis.asNumber(usage.outputTokens) ?? 0\n      } out`\n    }\n    case \"control.agent.cell-call-started\":\n      return `call ${Diagnosis.firstLine(Diagnosis.asString(payload.flowName) ?? \"?\")}`\n    case \"control.agent.cell-call-settled\":\n      return Diagnosis.asString(payload.outcome) === \"failure\"\n        ? `  -> FAIL ${Diagnosis.clip(Diagnosis.firstLine(Diagnosis.asString(payload.message) ?? \"\"), 100)}`\n        : \"  -> ok\"\n    case \"control.agent.resolved\":\n      return `resolved ${Diagnosis.clip(Diagnosis.firstLine(Diagnosis.asString(payload.text) ?? \"\"), 100)}`\n    case \"control.approval.requested\":\n      return `approval requested: ${Diagnosis.firstLine(Diagnosis.asString(payload.question) ?? \"\")}`\n    default:\n      return kind.slice(\"control.\".length)\n  }\n}\n\n/** Fold health from the same authoritative summary and committed event buffer as the run card.\n * Invalid observations and foreign incarnations cannot color the current owner.\n * @category projections\n * @since 1.0.0\n */\nexport const statusRollup = (\n  run: ControlSchema.RunSummary,\n  events: ReadonlyArray<ControlSchema.ControlEvent>,\n  now: number\n): Health.StatusRollup => {\n  const incarnation = Health.runIncarnation(run)\n  const candidates: Array<Health.RecordedObservation> = []\n  const decode = Schema.decodeUnknownOption(Health.HealthObservation)\n  let evidenceSeq = 0\n  for (const event of events) {\n    if (event.kind === Health.statusObservedEventType) {\n      const reading = decode(event.payload)\n      if (reading._tag === \"Some\") candidates.push({ observation: reading.value, sequence: event.sequence })\n    } else if (!Monitor.isBookkeepingEvent(event.kind)) evidenceSeq = Math.max(evidenceSeq, event.sequence)\n  }\n  const latest = Health.latestObservation(candidates, `run:${run.runId}`, incarnation)\n  return Health.rollup({\n    subjectId: `run:${run.runId}`,\n    state: run.status,\n    incarnation,\n    waitingReason: run.waitingReason,\n    baseHealth: latest?.observation.baseHealth ??\n      Monitor.classify({ summary: run, events, beatsWithoutProgress: 0, stallBeats: 3 }),\n    latest,\n    now,\n    evidenceSeq,\n    updatedAt: run.updatedAt\n  })\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["/**\n * The stable wire rows the gateway serves for each projection, and the pure\n * folds that compute them from control-plane facts.\n *\n * These rows are the whole read contract. Nothing here exposes a store row, a\n * database column, or an engine type: every field is either a\n * `@smthrs/control` projection value or something folded out of the ordered\n * `ControlEvent` deltas `Control.watch` publishes. Wire names are the flows\n * names (`flowId`, `createdAt`, and the `ApprovalTarget.Node` envelope), so a\n * client written against the control plane reads these rows without a\n * translation table.\n *\n * @since 1.0.0\n */\n\nimport { ControlFacts, ControlSchema, Health, Monitor } from \"@smthrs/control\"\nimport * as Fault from \"@smthrs/flow/Fault\"\nimport { ExecutionFact } from \"@smthrs/journal\"\nimport { Schema } from \"effect\"\nimport * as Diagnosis from \"./Diagnosis.ts\"\nimport { callScope, openCallIndex, uniqueCallEvents } from \"./internal/callEvents.ts\"\nimport * as NativeResolution from \"./internal/nativeResolution.ts\"\nimport * as NodeEvents from \"./internal/nodeEvents.ts\"\n\n/**\n * One run, everything a run card displays, and the diagnosis of what happened\n * to it.\n *\n * `flowId` carries what the old wire split across `run.workflowKey` and\n * `run.workflow`, and `createdAt` carries `run.createdAtMs`: one flows name\n * each, rather than two spellings of one fact.\n *\n * @since 1.0.0\n * @category models\n */\nexport const RunSummaryRow = Schema.Struct({\n  runId: Schema.String,\n  flowId: Schema.String,\n  statusRollup: Schema.optional(Health.StatusRollup),\n  status: ControlSchema.RunStatus,\n  lifecycleProvenance: Schema.optional(ControlFacts.LifecycleProvenance),\n  executionProvenance: Schema.optional(ExecutionFact.Provenance),\n  createdAt: Schema.Number,\n  updatedAt: Schema.Number,\n  planId: Schema.optional(Schema.String),\n  planDigest: Schema.optional(Schema.String),\n  parentRunId: Schema.optional(Schema.String),\n  lineageId: Schema.optional(Schema.String),\n  roundOrdinal: Schema.optional(Schema.Number),\n  waitingReason: Schema.optional(Schema.String),\n  steeringPending: Schema.optional(Schema.Number),\n  cancellation: Schema.optional(ControlSchema.Cancellation),\n  /** When the run's approved deadline passes; absent for a run with none. */\n  deadlineAt: Schema.optional(Schema.Number),\n  /** The model seat the run's last opened turn ran on. */\n  seat: Schema.optional(Schema.String),\n  turns: Schema.Number,\n  calls: Schema.Number,\n  callsFailed: Schema.Number,\n  editsAttempted: Schema.Number,\n  editsSucceeded: Schema.Number,\n  inputTokens: Schema.Number,\n  outputTokens: Schema.Number,\n  /**\n   * One line: the run row's status plus the reason that most explains it.\n   *\n   * Lifecycle provenance distinguishes a covered control fact from a legacy\n   * snapshot or a separate engine observation. Missing facts never silently\n   * replace a newer observed state with the last recorded status.\n   */\n  verdict: Schema.String,\n  /** The whole diagnosis card, which the old wire called `whatHappened`. */\n  diagnosis: Schema.String,\n  finalOutput: Schema.optional(Schema.String),\n  /** The failed run's fault class and `<_tag>/<code>`, stamped when it failed. */\n  failureFault: Schema.optional(Fault.Class),\n  failureMessage: Schema.optional(Schema.String),\n  failureTag: Schema.optional(Schema.String)\n})\n\n/**\n * One run, everything a run card displays, and its diagnosis.\n *\n * @since 1.0.0\n * @category models\n */\nexport type RunSummaryRow = typeof RunSummaryRow.Type\n\n/**\n * One node of a run, as a tree view renders it.\n *\n * `label` carries what the old wire called `node.cardLabel`, and `seat`\n * carries `node.agent`: the model seat is the flows name for who ran a node.\n *\n * `nodeId` is the ordinal the call opened on, because the emitter names no\n * node. {@link runTree} says why.\n *\n * @since 1.0.0\n * @category models\n */\nexport const RunTreeRow = Schema.Struct({\n  runId: Schema.String,\n  nodeId: Schema.String,\n  label: Schema.String,\n  status: Schema.Literals([\"running\", \"completed\", \"failed\"]),\n  seat: Schema.optional(Schema.String),\n  startedAt: Schema.Number,\n  endedAt: Schema.optional(Schema.Number),\n  parentRunId: Schema.optional(Schema.String)\n})\n\n/**\n * One node of a run, as a tree view renders it.\n *\n * @since 1.0.0\n * @category models\n */\nexport type RunTreeRow = typeof RunTreeRow.Type\n\n/**\n * One approval a run is parked on, carrying the exact payload that decides it.\n *\n * `title` carries the old `approval.requestTitle` and `request` the old\n * `approval.request`; `payload` is the `ApprovalTarget.Node` envelope a client\n * submits back unchanged, so no client reconstructs authority.\n *\n * @since 1.0.0\n * @category models\n */\nexport const ApprovalRow = Schema.Struct({\n  runId: Schema.String,\n  /**\n   * The execution holding the wait, when this gate is a question a person owes\n   * an answer to and it is held below `runId`.\n   *\n   * `runId` is the run a person opened and the run a decision is addressed to;\n   * a `HumanTask` in a nested flow parks its own execution, and the two are\n   * different runs. Present only on such a gate, so a reader can tell a\n   * question rolled up from a tree from one the named run raised itself, and\n   * an inbox can list one question once however many ancestors carry it.\n   */\n  waitRunId: Schema.optional(Schema.String),\n  questionProvenance: Schema.optional(Schema.Literals([\"events\", \"legacy-observation\", \"unverified-observation\"])),\n  requestId: Schema.String,\n  title: Schema.String,\n  request: Schema.Json,\n  payload: ControlSchema.ApprovalPayload,\n  requestedAt: Schema.Number,\n  status: Schema.Literals([\"pending\", \"approved\", \"denied\"])\n})\n\n/**\n * One approval a run is parked on.\n *\n * @since 1.0.0\n * @category models\n */\nexport type ApprovalRow = typeof ApprovalRow.Type\n\n/**\n * The output one node produced.\n *\n * @since 1.0.0\n * @category models\n */\nexport const NodeOutputRow = Schema.Struct({\n  runId: Schema.String,\n  nodeId: Schema.String,\n  outcome: Schema.Literals([\"success\", \"failure\"]),\n  output: Schema.String,\n  settledAt: Schema.Number\n})\n\n/**\n * The output one node produced.\n *\n * @since 1.0.0\n * @category models\n */\nexport type NodeOutputRow = typeof NodeOutputRow.Type\n\n/**\n * How long one flow's nodes take, per action tag.\n *\n * `samples` is the number of measured executions behind the two percentiles,\n * and it is on the wire because a percentile over one sample and a percentile\n * over twenty are different claims. A tag with no measured execution has no\n * row at all: there is no shape here for an unmeasured prediction.\n *\n * @since 1.0.0\n * @category models\n */\nexport const FlowDurationRow = Schema.Struct({\n  flowId: Schema.String,\n  actionTag: Schema.String,\n  samples: Schema.Number,\n  p50Ms: Schema.Number,\n  p90Ms: Schema.Number\n})\n\n/**\n * How long one flow's nodes take, per action tag.\n *\n * @since 1.0.0\n * @category models\n */\nexport type FlowDurationRow = typeof FlowDurationRow.Type\n\n/**\n * One measured execution of one node, as a duration fold's sample.\n *\n * The action tag is the only part of a node's key material that survives a\n * re-key, which is why history is grouped by it rather than by node id or by\n * dispatch key.\n *\n * @since 1.0.0\n * @category models\n */\nexport interface NodeDuration {\n  readonly actionTag: string\n  readonly durationMs: number\n}\n\n/**\n * One line of a run's turn-by-turn transcript.\n *\n * @since 1.0.0\n * @category models\n */\nexport const TranscriptRow = Schema.Struct({\n  runId: Schema.String,\n  sequence: Schema.Number,\n  turn: Schema.Number,\n  at: Schema.Number,\n  kind: Schema.String,\n  /** Dispatch identity on current call records; absent on legacy history. */\n  callId: Schema.optional(Schema.String),\n  text: Schema.String\n})\n\n/**\n * One line of a run's turn-by-turn transcript.\n *\n * @since 1.0.0\n * @category models\n */\nexport type TranscriptRow = typeof TranscriptRow.Type\n\n/** Copies only the optional fields a run summary actually carries. */\nconst optional = <A>(key: string, value: A | undefined): Record<string, A> =>\n  value === undefined ? {} : { [key]: value }\n\n/**\n * Folds one run's summary and events into the served `run-summary` row.\n *\n * @param run the control-plane run summary\n * @param events that run's ordered control events\n * @param now the instant the row is rendered at\n * @param carry the digest of the events a bounded reader dropped before them\n * @since 1.0.0\n * @category projections\n */\nexport const runSummary = (\n  run: ControlSchema.RunSummary,\n  events: ReadonlyArray<ControlSchema.ControlEvent>,\n  now: number = Math.max(run.updatedAt, events.at(-1)?.occurredAt ?? 0),\n  carry?: Diagnosis.Digest | undefined\n): RunSummaryRow => {\n  const projected = ControlFacts.fold(events, run)\n  // Supplying a snapshot guarantees a run: uncovered facts retain that\n  // observation; only the event-only fold can return an absent run.\n  run = projected.run!\n  const native = ExecutionFact.foldControl(events, run.runId, run.executionView)\n  // The control fold remains control authority. Native lifecycle is independently\n  // replayed/verified against the coherent executor observation when available.\n  if (run.executionObservation === \"observed\" && native?.view !== undefined) {\n    const { root, current } = native.view\n    run = {\n      ...run,\n      status: current.status === \"pending\" ? \"accepted\" : current.status === \"suspended\"\n        ? current.waiting?.reason === \"approval\" ||\n            (native.view.humanWaits?.length ?? run.pendingWaits?.length ?? 0) > 0\n          ? \"waiting-approval\" :\n          \"parked\"\n        : current.status === \"running\" && (native.view.humanWaits?.length ?? run.pendingWaits?.length ?? 0) > 0\n        ? \"waiting-approval\" :\n        current.status,\n      waitingReason: current.status === \"suspended\" ? current.waiting?.reason : undefined,\n      parentRunId: root.parentRunId ?? undefined,\n      lineageId: root.lineageId,\n      roundOrdinal: root.roundOrdinal\n    }\n  }\n  // `carry` is the digest of the events a bounded reader dropped ahead of\n  // `events`. Combining it keeps turns, calls, edits and tokens exact for a run\n  // whose journal no longer fits one window, so the counters a run card shows\n  // describe the whole run and not just its tail.\n  const window = Diagnosis.digest(events, run.runId)\n  const facts = { ...(carry === undefined ? window : Diagnosis.combine(carry, window)), status: run.status }\n  return {\n    runId: run.runId,\n    flowId: run.flowId,\n    status: run.status,\n    lifecycleProvenance: projected.provenance,\n    ...optional(\"executionProvenance\", native?.provenance),\n    statusRollup: statusRollup(run, events, now),\n    createdAt: run.createdAt,\n    updatedAt: run.updatedAt,\n    ...optional(\"planId\", run.planId),\n    ...optional(\"planDigest\", run.planDigest),\n    ...optional(\"parentRunId\", run.parentRunId),\n    ...optional(\"lineageId\", run.lineageId),\n    ...optional(\"roundOrdinal\", run.roundOrdinal),\n    ...optional(\"waitingReason\", run.waitingReason),\n    ...optional(\"steeringPending\", run.steering?.pending),\n    ...optional(\"cancellation\", run.cancellation),\n    ...optional(\"deadlineAt\", run.deadlineAt),\n    ...optional(\"seat\", facts.seat),\n    turns: facts.turns,\n    calls: facts.calls,\n    callsFailed: facts.callsFailed,\n    editsAttempted: facts.editsAttempted,\n    editsSucceeded: facts.editsSucceeded,\n    inputTokens: facts.inputTokens,\n    outputTokens: facts.outputTokens,\n    verdict: Diagnosis.verdict(facts),\n    diagnosis: Diagnosis.render({ runId: run.runId, ...optional(\"flowId\", run.flowId) }, facts),\n    ...optional(\n      \"finalOutput\",\n      Diagnosis.resolvedOutput(facts) ?? (\n        run.status === \"failed\" && facts.fault?.tag.endsWith(\"/source_refused\") &&\n          facts.cause?.match(/source_refused: ([a-z_]+)/)\n          ? JSON.stringify({ message: facts.cause.match(/source_refused: ([a-z_]+)/)![0] })\n          : undefined\n      )\n    ),\n    ...(run.status === \"failed\" ? optional(\"failureFault\", facts.fault?.class) : {}),\n    ...(run.status === \"failed\" ? optional(\"failureTag\", facts.fault?.tag) : {}),\n    ...(run.status === \"failed\" ? optional(\"failureMessage\", facts.cause) : {})\n  }\n}\n\n/**\n * Claims a call by its durable dispatch identity. Legacy history has no id:\n * match only legacy starts by flow name (or FIFO when unnamed). A new\n * settlement can close a legacy start after an old parked run resumes, but\n * neither fallback may steal an identified call.\n */\nconst takeOpenCall = <\n  A extends { readonly flowName: string; readonly callId: string | undefined; readonly scope: string | undefined }\n>(\n  open: Array<A>,\n  callId: string | undefined,\n  flowName: string | undefined,\n  scope: string | undefined\n): A | undefined => {\n  const found = openCallIndex(open, callId, flowName, scope)\n  return found < 0 ? undefined : open.splice(found, 1)[0]\n}\n\n/**\n * One agent call, as every node projection sees it: the ordinal it opened on,\n * the seat that ran it, and the settlement that closed it, if one did.\n */\ninterface CallRecord {\n  readonly nodeId: string\n  readonly flowName: string\n  readonly seat: string | undefined\n  readonly startedAt: number\n  readonly settlement: CallSettlement | undefined\n}\n\n/** What closed a call, and where among the run's settlements it closed. */\ninterface CallSettlement {\n  /** The rank of this settlement among the run's, counting from one. */\n  readonly order: number\n  /** The run the settlement named, which a malformed journal can omit. */\n  readonly runId: string | undefined\n  readonly at: number\n  readonly outcome: \"success\" | \"failure\"\n  readonly output: string\n}\n\n/**\n * Folds one run's events into the agent calls it made, in the order they\n * opened.\n *\n * This is the only fold that assigns a call its `call-N` identity, records the\n * seat and time it opened on, and pairs a settlement with the call it closed.\n * A client asks for a node's output by the id a tree row carries, so the two\n * projections have to agree on that id; when they counted separately they\n * could disagree, and once did, because skipping an event before the ordinal\n * advanced shifted one fold's keys against the other's. The ordinal therefore\n * advances on every distinct start, whatever else that event is missing.\n * Identified duplicate starts and settlements are ignored. Old idless rows\n * retain their original ordinal/FIFO interpretation; their missing dispatch\n * identity cannot be reconstructed when same-name calls overlapped.\n *\n * `uniqueCallEvents` also normalizes native step facts, so this fold reads the\n * run's own records and one stream per step a module run dispatched. The three\n * classes `Diagnosis` names apply here too, field by field:\n *\n * | Field                   | Class           | Why                                                    |\n * | ----------------------- | --------------- | ------------------------------------------------------ |\n * | `nodeId` (`call-N`)     | aggregate       | one tree lists every call the run made, steps included |\n * | `flowName`, `startedAt` | aggregate       | read off the call's own record                         |\n * | `settlement`            | aggregate       | claimed by call identity within the recorded scope     |\n * | `seat`                  | scope dependent | who ran THIS call, so the turn must be this call's own |\n *\n * There is no root-only field here: a tree row describes a call, never the\n * run's answer or state. A new field has to name its class.\n */\nconst callHistory = (\n  events: ReadonlyArray<ControlSchema.ControlEvent>\n): ReadonlyArray<CallRecord> => {\n  const calls = new Map<string, CallRecord>()\n  const open: Array<\n    {\n      readonly callId: string | undefined\n      readonly flowName: string\n      readonly call: CallRecord\n      readonly scope: string | undefined\n    }\n  > = []\n  // The seat of the last turn opened in each scope. A module run interleaves\n  // steps in one journal, so the run-wide reading attributed one step's seat\n  // to another step's calls. A prompt run records one unscoped stream and\n  // reads exactly as it did.\n  const seats = new Map<string | undefined, string | undefined>()\n  let ordinal = 0\n  let settlements = 0\n\n  for (const event of uniqueCallEvents(events)) {\n    const payload = Diagnosis.asRecord(event.payload)\n    if (event.kind === \"control.agent.turn-opened\") {\n      const scope = callScope(event)\n      seats.set(scope, Diagnosis.asString(payload.seat) ?? seats.get(scope))\n      continue\n    }\n    if (event.kind === \"control.agent.cell-call-started\") {\n      const callId = Diagnosis.asString(payload.callId)\n      ordinal += 1\n      const nodeId = `call-${ordinal}`\n      const flowName = Diagnosis.asString(payload.flowName) ?? nodeId\n      const scope = callScope(event)\n      // This scope's own turn, else the run's. A step that opened no turn of\n      // its own borrows nothing from a sibling step.\n      const seat = seats.get(scope) ?? seats.get(undefined)\n      const call: CallRecord = { nodeId, flowName, seat, startedAt: Diagnosis.timeOf(event), settlement: undefined }\n      open.push({ callId, flowName, call, scope })\n      calls.set(nodeId, call)\n      continue\n    }\n    if (event.kind !== \"control.agent.cell-call-settled\") continue\n    const callId = Diagnosis.asString(payload.callId)\n    const claimed = takeOpenCall(open, callId, Diagnosis.asString(payload.flowName), callScope(event))\n    if (claimed === undefined) continue\n    const failed = Diagnosis.asString(payload.outcome) === \"failure\"\n    settlements += 1\n    // Rewriting the entry keeps the call in the position it opened on, which\n    // is the order a tree renders.\n    calls.set(claimed.call.nodeId, {\n      ...claimed.call,\n      settlement: {\n        order: settlements,\n        runId: Diagnosis.asString(payload.runId) ?? event.runId,\n        at: Diagnosis.timeOf(event),\n        outcome: failed ? \"failure\" : \"success\",\n        output: failed\n          ? Diagnosis.asString(payload.message) ?? \"\"\n          : Diagnosis.asString(payload.value) ?? JSON.stringify(payload.value ?? null)\n      }\n    })\n  }\n  return [...calls.values()]\n}\n\n/** How a tree row reports a call: settled the way it settled, or still running. */\nconst treeStatus = (settlement: CallSettlement | undefined): RunTreeRow[\"status\"] => {\n  if (settlement === undefined) return \"running\"\n  return settlement.outcome === \"failure\" ? \"failed\" : \"completed\"\n}\n\n/**\n * Folds one run's events into its node rows.\n *\n * A node opens on `control.agent.cell-call-started` and settles on the\n * matching `control.agent.cell-call-settled`.\n *\n * AgentSession journals the same `callId` from the harness's dispatch identity\n * on both records. Settlements join on it even when same-name calls overlap\n * and finish out of order. The distinct-start ordinal remains the published\n * `call-N` node key, preserving existing node links. Legacy records without\n * callId retain same-name FIFO pairing, restricted to other legacy records\n * (including a newly identified settlement of an old parked call).\n *\n * The durable engine's own `flows.engine.*` records are not folded here, but\n * that is a choice rather than a limit. A host keeps the control plane and the\n * engine in two databases with two journals (`@smthrs/cli`\n * `NodeControl.databasePath` and `executionDatabasePath`), and\n * `EngineJournalProjection` copies every engine entry of the run into the\n * control journal as a `control.engine.event` envelope, which is how\n * {@link nodeDurations} reads the node records. A tree row is an agent cell\n * call, so what an engine step did reaches this projection as the call that\n * made it.\n *\n * A node that never settled stays `running`, which is how a live tree renders\n * work in flight.\n *\n * @param run the control-plane run summary\n * @param events that run's ordered control events\n * @since 1.0.0\n * @category projections\n */\nexport const runTree = (\n  run: ControlSchema.RunSummary,\n  events: ReadonlyArray<ControlSchema.ControlEvent>\n): ReadonlyArray<RunTreeRow> =>\n  callHistory(events).map((call): RunTreeRow => ({\n    runId: run.runId,\n    nodeId: call.nodeId,\n    label: call.flowName,\n    status: treeStatus(call.settlement),\n    ...optional(\"seat\", call.seat),\n    startedAt: call.startedAt,\n    ...optional(\"endedAt\", call.settlement?.at),\n    ...optional(\"parentRunId\", run.parentRunId)\n  }))\n\n/**\n * The declared question of a human wait, as far as it can be read.\n *\n * `request` is whatever the wait wrote about itself, which for `HumanTask` is\n * `{task, name, kind, prompt, attempt, maxAttempts}`. A wait that declared\n * nothing \u2014 an older park, or a plugin's own \u2014 still produces a row, because a\n * gate a person cannot see is a run that waits forever; it just has less to\n * render.\n */\nconst questionOf = (wait: ControlSchema.PendingWait): Record<string, unknown> => Diagnosis.asRecord(wait.request)\n\n/**\n * One pending row for a human wait held anywhere in a run's tree.\n *\n * `runId` is the ROOT: this is the run a person opened, and the run a decision\n * is addressed to. `waitRunId` is the execution actually holding it, because a\n * client routes by run and the control plane routes within the tree.\n *\n * `requestId` is the wait point's own name (`coding-clarification#1`), which is\n * unique within a tree, stable across a re-read, and the name a `Signal`\n * addresses. The token travels in the request too, for a client that would\n * rather submit the exact durable address back.\n */\nconst humanWaitRow = (\n  run: ControlSchema.RunSummary,\n  wait: ControlSchema.PendingWait,\n  projected?: ExecutionFact.Observation,\n  questionProvenance: \"events\" | \"legacy-observation\" | \"unverified-observation\" = \"legacy-observation\"\n): ApprovalRow => {\n  const question = projected === undefined ? questionOf(wait) : Diagnosis.asRecord(projected.waiting?.request)\n  const name = wait.name ?? Diagnosis.asString(question[\"name\"]) ?? wait.token\n  const requestId = wait.attempt === undefined ? name : `${name}#${wait.attempt}`\n  const prompt = Diagnosis.asString(question[\"prompt\"])\n  const waitFlowId = projected?.flowName ?? wait.flowId\n  return {\n    runId: run.runId,\n    waitRunId: wait.runId,\n    questionProvenance,\n    requestId,\n    title: prompt ?? `Answer needed \u2014 ${name}`,\n    request: {\n      ...question,\n      kind: Diagnosis.asString(question[\"kind\"]) ?? \"ask\",\n      name,\n      ...(wait.attempt === undefined ? {} : { attempt: wait.attempt }),\n      ...(waitFlowId === undefined ? {} : { waitFlowId }),\n      token: wait.token\n    },\n    payload: {\n      target: {\n        _tag: \"Node\",\n        runId: run.runId,\n        requestId,\n        digest: wait.token,\n        // A human answer grants no capabilities: the envelope a decision binds\n        // to is the empty one, the same shape a flow with none carries.\n        envelope: { capabilities: [], flows: [], budget: {} }\n      },\n      scope: \"once\",\n      // The identity is the PARK, not its name: a loop that re-asks one\n      // question parks again under the same run, name and attempt, and a\n      // name-keyed answer would deduplicate the second decision into the\n      // first \u2014 accepted, never delivered, and parked forever.\n      idempotencyKey: `answer:${run.runId}:${requestId}:${wait.tokenDigest ?? wait.token}`\n    },\n    requestedAt: projected?.createdAtMs ?? wait.createdAt,\n    status: \"pending\"\n  }\n}\n\n/**\n * Folds one run's events into its approval rows.\n *\n * A request opens a pending row carrying the submit-ready payload; the\n * matching `control.approval.approved` or `control.approval.denied` closes it\n * without discarding the request, so a decided gate stays readable.\n *\n * A `HumanTask` declares its question on the parked row. Native execution\n * facts carry the redacted question and token digest; verified facts supply\n * its display metadata here. `@smthrs/control` rolls current open waits onto\n * the root as `pendingWaits`, which supply each row's protected wake address.\n * History alone cannot create an answerable human wait. Older observations\n * remain visible with explicit question provenance when native fact coverage\n * is unavailable. These rows come first because they still need an answer.\n *\n * A decision names the gate it closed by `tokenId`. `@smthrs/control`\n * `SqlControlRuntime.lookupApproval` mints that token id from the target, and\n * for the `Node` target a run parks on it is the request id itself, so the two\n * records join on one field. A decision whose `tokenId` or `requestId` names\n * no row is retained for an exact later request. Only a legacy decision that\n * names neither field closes the oldest pending legacy row in that run.\n * Current facts bind the target digest; duplicates cannot reopen a decision.\n *\n * @param events the run's ordered control events\n * @since 1.0.0\n * @category projections\n */\nexport const approvals = (\n  events: ReadonlyArray<ControlSchema.ControlEvent>,\n  run?: ControlSchema.RunSummary | undefined\n): ReadonlyArray<ApprovalRow> => {\n  const native = run === undefined ? undefined : ExecutionFact.foldControl(events, run.runId, run.executionView)\n  const grantFacts = events.filter((event) =>\n    event.kind === \"control.approval.requested\" && Schema.is(ControlFacts.ApprovalRequestFact)(event.payload)\n  )\n  const grants = ControlFacts.fold(grantFacts).approvals\n  const observed = run?.pendingWaits?.map((wait) => {\n    // An agent ask parks on its registered grant token, not a HumanTask answer.\n    // Preserve the committed target instead of inventing an answer-only target.\n    const grant = grants.find((row) => row.runId === run.runId && row.requestId === wait.token)\n    if (grant !== undefined) return grant\n    const projected = native?.provenance.humanWaits === \"events\" ?\n      native.view?.humanWaits?.find((candidate) =>\n        candidate.executionId === wait.runId && candidate.waiting?.tokenDigest === wait.tokenDigest\n      ) :\n      undefined\n    return humanWaitRow(\n      run,\n      wait,\n      projected,\n      projected === undefined\n        ? native?.provenance.humanWaits === \"events\" ?\n          \"unverified-observation\" :\n          native?.provenance.humanWaits ?? \"legacy-observation\"\n        : \"events\"\n    )\n  })\n  // The current observation supplies wake authority. History supplies only the\n  // display metadata that verifies against that exact observed token digest.\n  return ControlFacts.fold(events, undefined, observed).approvals\n}\n\n/**\n * Folds one run's events into its node outputs, keyed the way {@link runTree}\n * keys its rows: by the ordinal the call opened on.\n *\n * A settled call carries the value it produced, so the row carries that value.\n * A run's own result reaches a client as `RunSummaryRow.finalOutput` instead.\n *\n * @param events the run's ordered control events\n * @since 1.0.0\n * @category projections\n */\nexport const nodeOutput = (\n  events: ReadonlyArray<ControlSchema.ControlEvent>\n): ReadonlyArray<NodeOutputRow> => {\n  const settled: Array<{ readonly order: number; readonly row: NodeOutputRow }> = []\n  for (const call of callHistory(events)) {\n    const settlement = call.settlement\n    if (settlement === undefined) continue\n    // A row names the run it belongs to. A settlement that names none closes\n    // its call without producing one.\n    if (settlement.runId === undefined) continue\n    settled.push({\n      order: settlement.order,\n      row: {\n        runId: settlement.runId,\n        nodeId: call.nodeId,\n        outcome: settlement.outcome,\n        output: settlement.output,\n        settledAt: settlement.at\n      }\n    })\n  }\n  // A tree reads in the order calls opened; outputs read in the order they\n  // settled, which is the order a client watched them arrive.\n  return settled.sort((left, right) => left.order - right.order).map((entry) => entry.row)\n}\n\n/** The node id every execution gives the flow it was started to run. */\nconst rootNodeId = \"root\"\n\n/**\n * The native execution the host bound this control run to, when one is known.\n *\n * Only the host's own binding record names the root, and two records that\n * disagree name nothing: an ambiguous binding cannot tell a callee's\n * execution apart from the root's, so it authorizes no skip.\n *\n * The binding is written once, when the host takes the root up, so a window\n * bounded to a run's newest events is the one window it falls out of. The\n * carried digest keeps it across that eviction, and reading from the carry is\n * what keeps a long run's calls counted the same as a short run's.\n */\nconst boundExecution = (\n  events: ReadonlyArray<ControlSchema.ControlEvent>,\n  carry: Diagnosis.Digest | undefined\n): string | undefined => {\n  let resolution = carry?.nativeResolution\n  for (const event of events) resolution = NativeResolution.combine(resolution, NativeResolution.fromEvent(event))\n  return resolution === undefined || resolution.conflict === true ? undefined : resolution.binding?.executionId\n}\n\n/**\n * A callee's own view of a call its caller already measured.\n *\n * Every execution below the bound root was started by a `FlowCall` node in\n * the execution above it, and that node carries the same action tag over the\n * same span. The caller's node is the one kept, because it is the node a plan\n * carries and the one a graph can join a prediction onto.\n *\n * With no binding nothing is echoed: a fold that cannot name the root cannot\n * tell which `root` record belongs to it, and dropping samples on a guess\n * would answer a smaller history than the flow ran.\n */\nconst echoedRoot = (bound: string | undefined, executionId: string, nodeId: string): boolean =>\n  bound !== undefined && nodeId === rootNodeId && executionId !== bound\n\n/**\n * Folds one run's events into the executions it measured.\n *\n * A node's work starts when the engine recorded it scheduled and ends when it\n * recorded it settled, so a duration is the distance between those two native\n * stamps. Four of the five outcomes contribute nothing: `clean` was served\n * from records rather than run, `failed` measures a collapse, `skipped` was\n * never reached, and `deferred` is scheduling debt. Only `built` ran.\n *\n * A settlement pairs with the LAST schedule of the same execution and node,\n * which is what makes a retried node measure its final attempt rather than\n * the span across every attempt. Two executions of one node id stay apart\n * because the pairing key carries the execution, and a settlement no schedule\n * opened measures nothing rather than measuring from zero.\n *\n * A record that names no action tag contributes nothing either: history is\n * grouped by tag, and a sample with no tag has nowhere honest to go.\n *\n * A called flow is measured once. The engine records one call twice: the\n * caller admits and settles the node that made it, and the callee's own\n * execution admits and settles its `root` over the same span with the same\n * action tag. {@link echoedRoot} drops the callee's copy, so one invocation\n * is one sample rather than two, and `samples` stays the count of executions\n * the flow performed.\n *\n * @param events the run's ordered control events\n * @param carry the digest of the events a bounded window dropped, when it dropped any\n * @since 1.0.0\n * @category projections\n */\nexport const nodeDurations = (\n  events: ReadonlyArray<ControlSchema.ControlEvent>,\n  carry?: Diagnosis.Digest | undefined\n): ReadonlyArray<NodeDuration> => {\n  const bound = boundExecution(events, carry)\n  const started = new Map<string, number>()\n  const measured: Array<NodeDuration> = []\n  for (const event of events) {\n    const schedule = NodeEvents.nodeScheduled(event)\n    if (schedule !== undefined) {\n      if (echoedRoot(bound, schedule.executionId, schedule.payload.nodeId)) continue\n      started.set(`${schedule.executionId}\\u0000${schedule.payload.nodeId}`, schedule.emittedAtMs)\n      continue\n    }\n    const settlement = NodeEvents.nodeSettled(event)\n    if (settlement === undefined) continue\n    if (echoedRoot(bound, settlement.executionId, settlement.payload.nodeId)) continue\n    if (settlement.payload.outcome !== \"built\") continue\n    const actionTag = settlement.payload.action\n    if (actionTag === undefined) continue\n    const key = `${settlement.executionId}\\u0000${settlement.payload.nodeId}`\n    const startedAt = started.get(key)\n    if (startedAt === undefined) continue\n    started.delete(key)\n    const durationMs = settlement.emittedAtMs - startedAt\n    // Wall clocks can move backwards, and a completion that predates its own\n    // start is a clock fact rather than a duration.\n    if (durationMs < 0) continue\n    measured.push({ actionTag, durationMs })\n  }\n  return measured\n}\n\n/** The nearest-rank percentile of an ascending sample, which is one observed value. */\nconst nearestRank = (ascending: ReadonlyArray<number>, percentile: number): number =>\n  ascending[Math.ceil((percentile / 100) * ascending.length) - 1]!\n\n/**\n * Folds every measured execution of one flow into one row per action tag.\n *\n * Both percentiles are nearest-rank, so each answer is a duration the flow\n * really took rather than an interpolation between two it did not. Rows are\n * ordered by tag, so two reads of the same history answer in the same order.\n *\n * A tag reaches this function only by having been measured, so every row\n * carries at least one sample, and a flow nothing has measured answers with\n * no rows at all.\n *\n * @param flowId the flow whose history was read\n * @param samples every measured execution of that flow's runs\n * @since 1.0.0\n * @category projections\n */\nexport const flowDurations = (\n  flowId: string,\n  samples: ReadonlyArray<NodeDuration>\n): ReadonlyArray<FlowDurationRow> => {\n  const byTag = new Map<string, Array<number>>()\n  for (const sample of samples) {\n    const held = byTag.get(sample.actionTag)\n    if (held === undefined) byTag.set(sample.actionTag, [sample.durationMs])\n    else held.push(sample.durationMs)\n  }\n  return [...byTag.entries()]\n    .sort(([left], [right]) => left < right ? -1 : 1)\n    .map(([actionTag, observed]) => {\n      const ascending = [...observed].sort((left, right) => left - right)\n      return {\n        flowId,\n        actionTag,\n        samples: ascending.length,\n        p50Ms: nearestRank(ascending, 50),\n        p90Ms: nearestRank(ascending, 90)\n      }\n    })\n}\n\n/** Events the transcript reports verbatim rather than as agent activity. */\nconst transcriptKinds: ReadonlySet<string> = new Set([\"control.approval.requested\"])\n\n/**\n * Folds one run's events into a turn-numbered transcript.\n *\n * A row is reported for every `control.run.*` and `control.agent.*` event and\n * for an approval request, and for nothing else: the transcript is what a\n * reader follows, not the whole journal, which `run-events` already serves.\n * The turn counter advances on `control.agent.turn-opened`, so every row\n * carries the turn it belongs to, and each row's text is one display line, so\n * a multi-line seat, message, or question cannot split one row into several.\n *\n * `uniqueCallEvents` normalizes native step facts, so a module run's steps\n * report here too. The classes `Diagnosis` names apply, field by field:\n *\n * | Field  | Class     | Why                                                       |\n * | ------ | --------- | --------------------------------------------------------- |\n * | rows   | aggregate | every row is one event this run recorded, wherever it ran |\n * | `turn` | aggregate | a turn a step opened is a turn this run opened            |\n *\n * No row is root only, because no row claims to be the run's answer or state:\n * a `control.agent.resolved` row says one agent resolved, and the run's own\n * answer is served by `runSummary` from `Diagnosis`. A new field has to name\n * its class.\n *\n * @param events the run's ordered control events\n * @since 1.0.0\n * @category projections\n */\nexport const transcript = (\n  events: ReadonlyArray<ControlSchema.ControlEvent>\n): ReadonlyArray<TranscriptRow> => {\n  const rows: Array<TranscriptRow> = []\n  let turn = 0\n  for (const event of uniqueCallEvents(events)) {\n    const payload = Diagnosis.asRecord(event.payload)\n    const runId = Diagnosis.asString(payload.runId) ?? event.runId\n    if (runId === undefined) continue\n    const reported = event.kind.startsWith(\"control.run.\") ||\n      event.kind.startsWith(\"control.agent.\") ||\n      transcriptKinds.has(event.kind)\n    if (!reported) continue\n    if (event.kind === \"control.agent.turn-opened\") turn += 1\n    rows.push({\n      runId,\n      sequence: event.sequence,\n      turn,\n      at: Diagnosis.timeOf(event),\n      kind: event.kind,\n      ...optional(\"callId\", Diagnosis.asString(payload.callId)),\n      text: line(event.kind, payload)\n    })\n  }\n  return rows\n}\n\n/** One event as a single transcript line. */\nconst line = (kind: string, payload: Record<string, unknown>): string => {\n  switch (kind) {\n    case \"control.agent.turn-opened\":\n      return `turn opened \u00B7 ${Diagnosis.firstLine(Diagnosis.asString(payload.seat) ?? \"\")}`\n    case \"control.agent.model-settled\": {\n      const usage = Diagnosis.asRecord(payload.usage)\n      return `model ${Diagnosis.asNumber(usage.inputTokens) ?? 0} in / ${\n        Diagnosis.asNumber(usage.outputTokens) ?? 0\n      } out`\n    }\n    case \"control.agent.cell-call-started\":\n      return `call ${Diagnosis.firstLine(Diagnosis.asString(payload.flowName) ?? \"?\")}`\n    case \"control.agent.cell-call-settled\":\n      return Diagnosis.asString(payload.outcome) === \"failure\"\n        ? `  -> FAIL ${Diagnosis.clip(Diagnosis.firstLine(Diagnosis.asString(payload.message) ?? \"\"), 100)}`\n        : \"  -> ok\"\n    case \"control.agent.resolved\":\n      return `resolved ${Diagnosis.clip(Diagnosis.firstLine(Diagnosis.asString(payload.text) ?? \"\"), 100)}`\n    case \"control.approval.requested\":\n      return `approval requested: ${Diagnosis.firstLine(Diagnosis.asString(payload.question) ?? \"\")}`\n    default:\n      return kind.slice(\"control.\".length)\n  }\n}\n\n/** Fold health from the same authoritative summary and committed event buffer as the run card.\n * Invalid observations and foreign incarnations cannot color the current owner.\n * @category projections\n * @since 1.0.0\n */\nexport const statusRollup = (\n  run: ControlSchema.RunSummary,\n  events: ReadonlyArray<ControlSchema.ControlEvent>,\n  now: number\n): Health.StatusRollup => {\n  const incarnation = Health.runIncarnation(run)\n  const candidates: Array<Health.RecordedObservation> = []\n  const decode = Schema.decodeUnknownOption(Health.HealthObservation)\n  let evidenceSeq = 0\n  for (const event of events) {\n    if (event.kind === Health.statusObservedEventType) {\n      const reading = decode(event.payload)\n      if (reading._tag === \"Some\") candidates.push({ observation: reading.value, sequence: event.sequence })\n    } else if (!Monitor.isBookkeepingEvent(event.kind)) evidenceSeq = Math.max(evidenceSeq, event.sequence)\n  }\n  const latest = Health.latestObservation(candidates, `run:${run.runId}`, incarnation)\n  return Health.rollup({\n    subjectId: `run:${run.runId}`,\n    state: run.status,\n    incarnation,\n    waitingReason: run.waitingReason,\n    baseHealth: latest?.observation.baseHealth ??\n      Monitor.classify({ summary: run, events, beatsWithoutProgress: 0, stallBeats: 3 }),\n    latest,\n    now,\n    evidenceSeq,\n    updatedAt: run.updatedAt\n  })\n}\n"],
+  "mappings": "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",
   "names": ["callId"]
 }

package/dist/cjs/GatewayRpcs.d.ts

@@ -302,6 +302,7 @@ export declare const GatewayRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Projection.Snapshot
         readonly diagnosis: Schema.String;
         readonly finalOutput: Schema.optional<Schema.String>;
         readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureMessage: Schema.optional<Schema.String>;
         readonly failureTag: Schema.optional<Schema.String>;
     }>>;
 }>, Schema.Struct<{
@@ -412,6 +413,7 @@ export declare const GatewayRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Projection.Snapshot
         readonly diagnosis: Schema.String;
         readonly finalOutput: Schema.optional<Schema.String>;
         readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureMessage: Schema.optional<Schema.String>;
         readonly failureTag: Schema.optional<Schema.String>;
     }>>;
 }>, Schema.Struct<{
@@ -869,6 +871,7 @@ export declare const GatewayRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Projection.Snapshot
         readonly diagnosis: Schema.String;
         readonly finalOutput: Schema.optional<Schema.String>;
         readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureMessage: Schema.optional<Schema.String>;
         readonly failureTag: Schema.optional<Schema.String>;
     }>;
 }>, Schema.TaggedStruct<"row", {
@@ -979,6 +982,7 @@ export declare const GatewayRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Projection.Snapshot
         readonly diagnosis: Schema.String;
         readonly finalOutput: Schema.optional<Schema.String>;
         readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureMessage: Schema.optional<Schema.String>;
         readonly failureTag: Schema.optional<Schema.String>;
     }>;
 }>, Schema.TaggedStruct<"row", {
@@ -1393,6 +1397,7 @@ export declare const GatewayRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Projection.Snapshot
         readonly diagnosis: Schema.String;
         readonly finalOutput: Schema.optional<Schema.String>;
         readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureMessage: Schema.optional<Schema.String>;
         readonly failureTag: Schema.optional<Schema.String>;
     }>>;
 }>, Schema.TaggedStruct<"delta", {
@@ -1503,6 +1508,7 @@ export declare const GatewayRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Projection.Snapshot
         readonly diagnosis: Schema.String;
         readonly finalOutput: Schema.optional<Schema.String>;
         readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureMessage: Schema.optional<Schema.String>;
         readonly failureTag: Schema.optional<Schema.String>;
     }>>;
 }>, Schema.TaggedStruct<"delta", {

package/dist/cjs/GatewayRpcs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GatewayRpcs.d.ts","sourceRoot":"","sources":["../../src/GatewayRpcs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,YAAY,EAAE,WAAW,EAAiB,MAAM,iBAAiB,CAAA;AAC1E,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAEhD,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,+CAAuC,CAAA;AAE5D;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;IAG9B;;;;;;;;;;;;OAYG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEH,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAA;AAEjE;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;EAE/B,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAoCnE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA1FtB;;;;;;;;;;;;OAYG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yKAsHgC,CAAA"}
+{"version":3,"file":"GatewayRpcs.d.ts","sourceRoot":"","sources":["../../src/GatewayRpcs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,YAAY,EAAE,WAAW,EAAiB,MAAM,iBAAiB,CAAA;AAC1E,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAEhD,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,+CAAuC,CAAA;AAE5D;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;IAG9B;;;;;;;;;;;;OAYG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEH,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAA;AAEjE;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;EAE/B,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAoCnE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA1FtB;;;;;;;;;;;;OAYG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yKAsHgC,CAAA"}

package/dist/cjs/GatewaySchema.d.ts

@@ -253,6 +253,7 @@ declare const served: readonly [readonly [Schema.TaggedStruct<"workspace-runs",
     readonly diagnosis: Schema.String;
     readonly finalOutput: Schema.optional<Schema.String>;
     readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+    readonly failureMessage: Schema.optional<Schema.String>;
     readonly failureTag: Schema.optional<Schema.String>;
 }>], readonly [Schema.TaggedStruct<"run-summary", {
     readonly runId: Schema.String;
@@ -336,6 +337,7 @@ declare const served: readonly [readonly [Schema.TaggedStruct<"workspace-runs",
     readonly diagnosis: Schema.String;
     readonly finalOutput: Schema.optional<Schema.String>;
     readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+    readonly failureMessage: Schema.optional<Schema.String>;
     readonly failureTag: Schema.optional<Schema.String>;
 }>], readonly [Schema.TaggedStruct<"run-events", {
     readonly runId: Schema.String;
@@ -666,6 +668,7 @@ export declare const ProjectionSnapshot: Schema.Union<readonly [Schema.Struct<{
         readonly diagnosis: Schema.String;
         readonly finalOutput: Schema.optional<Schema.String>;
         readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureMessage: Schema.optional<Schema.String>;
         readonly failureTag: Schema.optional<Schema.String>;
     }>>;
 }>, Schema.Struct<{
@@ -776,6 +779,7 @@ export declare const ProjectionSnapshot: Schema.Union<readonly [Schema.Struct<{
         readonly diagnosis: Schema.String;
         readonly finalOutput: Schema.optional<Schema.String>;
         readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureMessage: Schema.optional<Schema.String>;
         readonly failureTag: Schema.optional<Schema.String>;
     }>>;
 }>, Schema.Struct<{
@@ -1218,6 +1222,7 @@ export declare const RowFrame: Schema.Union<readonly [Schema.TaggedStruct<"row",
         readonly diagnosis: Schema.String;
         readonly finalOutput: Schema.optional<Schema.String>;
         readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureMessage: Schema.optional<Schema.String>;
         readonly failureTag: Schema.optional<Schema.String>;
     }>;
 }>, Schema.TaggedStruct<"row", {
@@ -1328,6 +1333,7 @@ export declare const RowFrame: Schema.Union<readonly [Schema.TaggedStruct<"row",
         readonly diagnosis: Schema.String;
         readonly finalOutput: Schema.optional<Schema.String>;
         readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureMessage: Schema.optional<Schema.String>;
         readonly failureTag: Schema.optional<Schema.String>;
     }>;
 }>, Schema.TaggedStruct<"row", {
@@ -1775,6 +1781,7 @@ export declare const DeltaFrame: Schema.Union<readonly [Schema.TaggedStruct<"del
         readonly diagnosis: Schema.String;
         readonly finalOutput: Schema.optional<Schema.String>;
         readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureMessage: Schema.optional<Schema.String>;
         readonly failureTag: Schema.optional<Schema.String>;
     }>>;
 }>, Schema.TaggedStruct<"delta", {
@@ -1885,6 +1892,7 @@ export declare const DeltaFrame: Schema.Union<readonly [Schema.TaggedStruct<"del
         readonly diagnosis: Schema.String;
         readonly finalOutput: Schema.optional<Schema.String>;
         readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureMessage: Schema.optional<Schema.String>;
         readonly failureTag: Schema.optional<Schema.String>;
     }>>;
 }>, Schema.TaggedStruct<"delta", {
@@ -2329,6 +2337,7 @@ export declare const GatewayFrame: Schema.Union<readonly [Schema.TaggedStruct<"s
         readonly diagnosis: Schema.String;
         readonly finalOutput: Schema.optional<Schema.String>;
         readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureMessage: Schema.optional<Schema.String>;
         readonly failureTag: Schema.optional<Schema.String>;
     }>;
 }>, Schema.TaggedStruct<"row", {
@@ -2439,6 +2448,7 @@ export declare const GatewayFrame: Schema.Union<readonly [Schema.TaggedStruct<"s
         readonly diagnosis: Schema.String;
         readonly finalOutput: Schema.optional<Schema.String>;
         readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureMessage: Schema.optional<Schema.String>;
         readonly failureTag: Schema.optional<Schema.String>;
     }>;
 }>, Schema.TaggedStruct<"row", {
@@ -2853,6 +2863,7 @@ export declare const GatewayFrame: Schema.Union<readonly [Schema.TaggedStruct<"s
         readonly diagnosis: Schema.String;
         readonly finalOutput: Schema.optional<Schema.String>;
         readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureMessage: Schema.optional<Schema.String>;
         readonly failureTag: Schema.optional<Schema.String>;
     }>>;
 }>, Schema.TaggedStruct<"delta", {
@@ -2963,6 +2974,7 @@ export declare const GatewayFrame: Schema.Union<readonly [Schema.TaggedStruct<"s
         readonly diagnosis: Schema.String;
         readonly finalOutput: Schema.optional<Schema.String>;
         readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
+        readonly failureMessage: Schema.optional<Schema.String>;
         readonly failureTag: Schema.optional<Schema.String>;
     }>>;
 }>, Schema.TaggedStruct<"delta", {

package/dist/cjs/GatewaySchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GatewaySchema.d.ts","sourceRoot":"","sources":["../../src/GatewaySchema.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"GatewaySchema.d.ts","sourceRoot":"","sources":["../../src/GatewaySchema.ts"],"names":[],"mappings":"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"}

package/dist/cjs/RuntimeBridge.d.ts

@@ -617,6 +617,7 @@ export declare const observe: (control: Control["Service"], input: ObserveReques
     run: {
         failureFault?: Fault.Class;
         failureTag?: string;
+        failureMessage?: string;
         finalOutput?: string;
         commandReceipt?: {
             readonly runId: string;
@@ -1217,6 +1218,7 @@ export declare const ObserveResponse: Schema.Struct<{
             readonly finalOutput: Schema.optional<Schema.String>;
             readonly failureFault: Schema.optional<Schema.Literals<readonly ["user", "wait", "infra", "dependency", "bug", "factory", "policy"]>>;
             readonly failureTag: Schema.optional<Schema.String>;
+            readonly failureMessage: Schema.optional<Schema.String>;
             readonly commandReceipt: Schema.optionalKey<Schema.Struct<{
                 readonly runId: Schema.NonEmptyString;
                 readonly operationId: Schema.NonEmptyString;

package/dist/cjs/RuntimeBridge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RuntimeBridge.d.ts","sourceRoot":"","sources":["../../src/RuntimeBridge.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"RuntimeBridge.d.ts","sourceRoot":"","sources":["../../src/RuntimeBridge.ts"],"names":[],"mappings":"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"}

package/dist/cjs/RuntimeBridge.js

@@ -375,7 +375,8 @@ const observe = (control, input, receipts) => import_effect.Effect.gen(function*
     finalOutput = row.finalOutput;
     failure = {
       ...row.failureFault === void 0 ? {} : { failureFault: row.failureFault },
-      ...row.failureTag === void 0 ? {} : { failureTag: row.failureTag }
+      ...row.failureTag === void 0 ? {} : { failureTag: row.failureTag },
+      ...row.failureMessage === void 0 ? {} : { failureMessage: row.failureMessage }
     };
   }
   const hostSummary = yield* import_effect.Schema.decodeUnknownEffect(import_ControlSchema.RunSummary)(summary);
@@ -499,6 +500,7 @@ const ObserveResponse = import_effect.Schema.Struct({
       finalOutput: import_effect.Schema.optional(import_effect.Schema.String),
       failureFault: import_effect.Schema.optional(Fault.Class),
       failureTag: import_effect.Schema.optional(import_effect.Schema.String),
+      failureMessage: import_effect.Schema.optional(import_effect.Schema.String),
       commandReceipt: import_effect.Schema.optionalKey(CommandReceipt)
     }),
     events: import_effect.Schema.Array(import_ControlSchema.ControlEvent),