@smthrs/gateway 0.35.0 → 1.0.0-rc.3

package/dist/cjs/RunTrace.js

@@ -0,0 +1,1593 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var RunTrace_exports = {};
+__export(RunTrace_exports, {
+  TRACE_FILTER_IDS: () => TRACE_FILTER_IDS,
+  callSemantics: () => callSemantics,
+  callSubject: () => callSubject,
+  durationWords: () => durationWords,
+  inspectLabel: () => import_inspectLabels2.inspectLabel,
+  isTraceFilter: () => isTraceFilter,
+  monitorFromJournal: () => monitorFromJournal,
+  phaseBandGeometry: () => phaseBandGeometry,
+  phaseExtent: () => phaseExtent,
+  runMemoryOf: () => runMemoryOf,
+  spanMatches: () => spanMatches,
+  spanPath: () => spanPath,
+  traceFiltersFor: () => traceFiltersFor,
+  traceFold: () => traceFold,
+  traceFoldModel: () => traceFoldModel,
+  traceFoldStep: () => traceFoldStep,
+  traceFoldSync: () => traceFoldSync,
+  traceFromJournal: () => traceFromJournal,
+  turnNarratives: () => turnNarratives,
+  waterfallGeometry: () => waterfallGeometry
+});
+module.exports = __toCommonJS(RunTrace_exports);
+var import_journal = require("@smthrs/journal");
+var import_Descriptor = require("@smthrs/registry/Descriptor");
+var import_effect = require("effect");
+var import_Diagnosis = require("./Diagnosis.js");
+var import_EngineTrace = require("./EngineTrace.js");
+var import_actionRenderings = require("./internal/actionRenderings.js");
+var import_callEvents = require("./internal/callEvents.js");
+var import_inspectLabels = require("./internal/inspectLabels.js");
+var import_inspectLabels2 = require("./internal/inspectLabels.js");
+const TERMINAL_RUN = /* @__PURE__ */ new Set(["completed", "failed", "cancelled", "no-capacity"]);
+const asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+const asString = (value) => typeof value === "string" ? value : void 0;
+const asNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+const timeOf = (record, payload) => asNumber(payload.at) ?? asNumber(record.occurredAt) ?? 0;
+const textOf = (value) => {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+};
+const restOf = (payload, shown) => {
+  const rest = {};
+  for (const [key, value] of Object.entries(payload)) {
+    if (shown.includes(key) || key === "at" || key === "journalVersion") continue;
+    rest[key] = value;
+  }
+  return Object.keys(rest).length === 0 ? void 0 : rest;
+};
+const builder = (id, kind, label, status, startedAt, detail) => ({ id, kind, label, status, startedAt, children: [], detail });
+const legacy = (activity, pending, success, failure, subject, result) => ({
+  ...activity === void 0 ? {} : { activity },
+  presentation: { verb: { pending, success, failure }, subject, result }
+});
+const LEGACY_PRESENTATION = /* @__PURE__ */ new Map([
+  // `bash` has no compatibility activity for the same reason `@smthrs/std`
+  // declares none: what a shell call does is in the command, which the rule
+  // below reads off the record.
+  ["bash", legacy(void 0, "running", "ran", "failed to run", "command", "command")],
+  ["test", legacy("tests", "running", "ran", "failed to run", "selection", "tests")],
+  ["edit", legacy("writes", "editing", "edited", "failed to edit", "path", "edit")],
+  ["write", legacy("writes", "writing", "wrote", "failed to write", "path", "write")],
+  ["apply_patch", legacy("writes", "patching", "patched", "failed to patch", "patch", "patch")],
+  ["read", legacy("reads", "reading", "read", "failed to read", "path", "read")],
+  ["grep", legacy("reads", "searching", "searched", "failed to search", "pattern", "matches")],
+  ["glob", legacy("reads", "listing", "listed", "failed to list", "pattern", "paths")],
+  ["ls", legacy("reads", "listing", "listed", "failed to list", "path", "entries")]
+]);
+const recordedMetadata = (value, flowName) => {
+  const descriptor = asRecord(value);
+  if (descriptor.name !== flowName) return void 0;
+  if (descriptor.activity === void 0 && descriptor.presentation === void 0) return void 0;
+  const activity = import_effect.Schema.is(import_Descriptor.FlowActivity)(descriptor.activity) ? descriptor.activity : void 0;
+  const presentation = import_effect.Schema.is(import_Descriptor.CallPresentation)(descriptor.presentation) ? descriptor.presentation : void 0;
+  return { activity, presentation };
+};
+const CHECKPOINT_FLOW = "checkpoint";
+const commandOf = (input) => {
+  const fields = asRecord(input);
+  return asString(fields.command) ?? asString(fields.script);
+};
+const basename = (path) => path.split("/").filter((part) => part !== "").pop() ?? path;
+const patchedPaths = (patch) => {
+  const paths = [];
+  for (const line of patch.split("\n")) {
+    const named = /^\*\*\* (?:Add|Delete|Update) File:\s*(\S.*)$/.exec(line.trim())?.[1];
+    if (named !== void 0) paths.push(named.trim());
+  }
+  return paths;
+};
+const filesLabel = (paths) => {
+  const first = paths[0];
+  if (first === void 0) return "";
+  return paths.length === 1 ? basename(first) : `${basename(first)} +${paths.length - 1}`;
+};
+const writtenPaths = (input) => {
+  const fields = asRecord(input);
+  const path = asString(fields.path);
+  if (path !== void 0) return [path];
+  const patch = asString(fields.input);
+  return patch === void 0 ? [] : patchedPaths(patch);
+};
+const callSubject = (input, format) => {
+  const fields = asRecord(input);
+  if (format === "none") return "";
+  if (format === "path") return asString(fields.path) === void 0 ? "" : basename(fields.path);
+  if (format === "command") return commandOf(input) ?? "";
+  if (format === "patch") return filesLabel(patchedPaths(asString(fields.input) ?? ""));
+  if (format === "pattern") return asString(fields.pattern) ?? "";
+  if (format === "selection") return stringList(fields.selection)?.join(" ") ?? "";
+  const path = asString(fields.path);
+  if (path !== void 0) return basename(path);
+  const command = commandOf(input);
+  if (command !== void 0) return command;
+  const patch = asString(fields.input);
+  if (patch !== void 0) {
+    const files = filesLabel(patchedPaths(patch));
+    if (files !== "") return files;
+  }
+  const selection = Array.isArray(fields.selection) ? fields.selection.filter((one) => typeof one === "string") : void 0;
+  if (selection !== void 0 && selection.length > 0) return selection.join(" ");
+  return asString(fields.pattern) ?? "";
+};
+const shellActivity = (command) => {
+  if (/[;&|<>`$\n\r]/.test(command)) return "other";
+  const words = command.trim().split(/\s+/);
+  const first = words[0];
+  if (["pytest", "vitest", "jest"].includes(first)) return "tests";
+  if (/^python[23]?$/.test(first) && words[1] === "-m" && ["pytest", "unittest"].includes(words[2] ?? "")) {
+    return "tests";
+  }
+  if (first === "bun" && words[1] === "test") return "tests";
+  if (["pnpm", "npm", "bun"].includes(first)) {
+    if (words[1] === "test" || words[1] === "run" && words[2] === "test") return "tests";
+    if (words[1] === "exec" && ["vitest", "jest"].includes(words[2] ?? "")) return "tests";
+    if (words[1] === "run" && ["check", "typecheck", "lint"].includes(words[2] ?? "")) return "checks";
+  }
+  if (first === "go" && words[1] === "test") return "tests";
+  if (first === "cargo" && words[1] === "test") return "tests";
+  if (first === "tsc") return "checks";
+  return "other";
+};
+const callSemantics = (flowName, payload) => {
+  const recorded = recordedMetadata(payload.descriptor, flowName);
+  const metadata = recorded ?? LEGACY_PRESENTATION.get(flowName);
+  const activity = metadata?.activity ?? (flowName === "bash" ? shellActivity(commandOf(payload.input) ?? "") : void 0);
+  return {
+    ...activity === void 0 ? {} : { activity },
+    ...metadata?.presentation === void 0 ? {} : { presentation: metadata.presentation }
+  };
+};
+const stringList = (value) => Array.isArray(value) && value.every((entry) => typeof entry === "string") ? value : void 0;
+const countOf = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+const counted = (value, noun, plural = `${noun}s`) => `${value} ${value === 1 ? noun : plural}`;
+const resultOf = (value, format) => {
+  if (format === "none") return "";
+  if (typeof value === "string") return clip(value) ?? "";
+  const fields = asRecord(value);
+  if (fields.truncated === true && typeof fields.digest === "string") return "";
+  switch (format) {
+    case "read": {
+      const start = countOf(fields.startLine);
+      const end = countOf(fields.endLine);
+      return start !== void 0 && start > 0 && end !== void 0 && end >= start - 1 ? counted(end - start + 1, "line") : "";
+    }
+    case "write":
+      return countOf(fields.bytesWritten) === void 0 ? "" : counted(fields.bytesWritten, "byte");
+    case "edit":
+      return countOf(fields.replacements) === void 0 ? "" : counted(fields.replacements, "replacement");
+    case "patch": {
+      const groups = [stringList(fields.added), stringList(fields.modified), stringList(fields.deleted)];
+      return groups.every((group) => group !== void 0) ? counted(new Set(groups.flat()).size, "file") : "";
+    }
+    case "tests": {
+      const passed = countOf(fields.passed);
+      const failed = stringList(fields.failed);
+      if (fields.parsed === true && passed !== void 0 && failed !== void 0 && fields.invalidProbe === void 0) {
+        const exit = countOf(fields.exitCode);
+        return `${passed} passed${failed.length > 0 ? ` \xB7 ${failed.length} failed` : exit !== void 0 && exit !== 0 ? ` \xB7 exit ${exit}` : ""}`;
+      }
+      return countOf(fields.exitCode) === void 0 ? "" : `exit ${fields.exitCode}`;
+    }
+    case "command":
+      return countOf(fields.exitCode) === void 0 ? "" : `exit ${fields.exitCode}`;
+    case "matches":
+      return Array.isArray(fields.matches) ? counted(fields.matches.length, "match", "matches") : "";
+    case "paths":
+      return stringList(fields.paths) === void 0 ? "" : counted(fields.paths.length, "file");
+    case "entries":
+      return Array.isArray(fields.entries) ? counted(fields.entries.length, "entry", "entries") : "";
+    default:
+      return "";
+  }
+};
+const bodyOf = (...sentences) => sentences.filter((sentence) => sentence !== void 0).join(" ");
+const clip = (value) => {
+  const line = asString(value);
+  if (line === void 0 || line === "") return void 0;
+  return line.length <= 160 ? line : `${line.slice(0, 159).trimEnd()}\u2026`;
+};
+const madeAWrite = (entry) => entry.calls.some((call) => call.activity === "writes" && call.settled?.failed === false && !call.settled.denied);
+const dominantCall = (entry) => entry.calls.find((one) => one.activity === "writes") ?? entry.calls.find((one) => one.activity === "checks" || one.activity === "tests") ?? entry.calls.find((one) => one.flowName !== CHECKPOINT_FLOW);
+const disciplineInit = (runId) => ({
+  runId,
+  frames: [],
+  notes: [],
+  milestones: [],
+  owners: [],
+  open: [],
+  frame: void 0,
+  lastAt: 0,
+  lineOf: /* @__PURE__ */ new WeakMap()
+});
+const disciplineStep = (state, record) => {
+  const { runId, frames, notes, milestones, owners, open } = state;
+  let frame = state.frame;
+  const here = () => frame?.id ?? `run:${runId}`;
+  const note = (seq, tone, title, body, evidence) => {
+    const quoted = evidence.filter((line) => line !== void 0);
+    notes.push({ seq, spanId: here(), tone, title, body, ...quoted.length === 0 ? {} : { evidence: quoted } });
+  };
+  const pin = (seq, at, label, tone) => {
+    milestones.push({ seq, at, label, tone, spanId: here() });
+  };
+  {
+    const kind = record.kind ?? "";
+    const payload = asRecord(record.payload);
+    const at = timeOf(record, payload);
+    const seq = record.sequence ?? 0;
+    state.lastAt = Math.max(state.lastAt, at);
+    if (frame !== void 0) frame.endedAt = Math.max(frame.endedAt, at);
+    switch (kind) {
+      case "control.agent.turn-opened": {
+        frame = {
+          id: `frame-${frames.length + 1}`,
+          frame: frames.length + 1,
+          seq,
+          startedAt: at,
+          endedAt: at,
+          blocked: false,
+          calls: []
+        };
+        frames.push(frame);
+        break;
+      }
+      case "control.agent.cell-call-started": {
+        const flowName = asString(payload.flowName) ?? "";
+        const metadata = callSemantics(flowName, payload);
+        const call = {
+          flowName,
+          callId: asString(payload.callId),
+          input: payload.input,
+          activity: metadata.activity,
+          presentation: metadata.presentation,
+          signature: `${flowName} ${textOf(payload.input) ?? ""}`
+        };
+        open.push(call);
+        frame?.calls.push(call);
+        break;
+      }
+      case "control.agent.cell-call-settled": {
+        if (payload.outcome !== "success" && payload.outcome !== "failure") break;
+        const index = (0, import_Diagnosis.openCallIndex)(open, asString(payload.callId), asString(payload.flowName));
+        const call = index < 0 ? void 0 : open.splice(index, 1)[0];
+        if (call === void 0) break;
+        const failed = asString(payload.outcome) === "failure";
+        const denied = !failed && asRecord(payload.value).approved === false;
+        call.settled = {
+          failed,
+          result: (failed ? textOf(payload.message) : textOf(payload.value)) ?? "",
+          denied,
+          value: payload.value
+        };
+        if (denied && frame !== void 0) frame.blocked = true;
+        if (!failed && !denied && call.activity === "writes") {
+          const paths = [...new Set(writtenPaths(call.input))];
+          const minted = frame?.wrote;
+          if (minted !== void 0) {
+            for (const path of paths) if (!minted.paths.includes(path)) minted.paths.push(path);
+            milestones[minted.milestone] = { ...milestones[minted.milestone], label: filesLabel(minted.paths) };
+          } else if (paths.length > 0) {
+            if (frame !== void 0) frame.wrote = { milestone: milestones.length, paths };
+            pin(seq, at, filesLabel(paths), "brand");
+          }
+        }
+        break;
+      }
+      case "control.agent.mutation-observed": {
+        const mutated = payload.mutated === true;
+        if (frame !== void 0) frame.mutated = mutated;
+        if (frame !== void 0 && payload.basis === "observed" && typeof payload.mutated === "boolean") {
+          frame.observedMutation = payload.mutated;
+        }
+        if (mutated) {
+          note(
+            seq,
+            asString(payload.basis) === "observed" ? "good" : "warn",
+            "changed",
+            asString(payload.basis) ?? "",
+            []
+          );
+        }
+        break;
+      }
+      case "control.agent.permission-required": {
+        if (frame !== void 0) frame.blocked = true;
+        pin(seq, at, "permission", "warn");
+        break;
+      }
+      case "control.agent.suspended": {
+        if (frame !== void 0) frame.blocked = true;
+        break;
+      }
+      case "control.agent.checkpoint-minted": {
+        note(seq, "good", "checkpoint", asString(payload.ref) ?? "", []);
+        break;
+      }
+      case "control.agent.read-only-demanded": {
+        const streak = asNumber(payload.streak);
+        const cap = asNumber(payload.cap);
+        const nextFrame = asNumber(payload.nextFrame);
+        const nextAction = asString(payload.nextAction);
+        note(
+          seq,
+          "warn",
+          "read-only",
+          bodyOf(
+            streak === void 0 || cap === void 0 ? void 0 : `${streak} of ${cap} frames changed nothing.`,
+            nextFrame === void 0 || nextAction === void 0 ? void 0 : `Frame ${nextFrame}: ${nextAction}.`
+          ),
+          []
+        );
+        pin(seq, at, "read-only", "warn");
+        break;
+      }
+      case "control.agent.repeat-demanded": {
+        const spent = asNumber(payload.frames);
+        const cap = asNumber(payload.cap);
+        const nextFrame = asNumber(payload.nextFrame);
+        note(
+          seq,
+          "warn",
+          "repeat",
+          bodyOf(
+            spent === void 0 || cap === void 0 ? void 0 : `${spent} of ${cap} frames repeated calls.`,
+            nextFrame === void 0 ? void 0 : `Frame ${nextFrame}.`
+          ),
+          []
+        );
+        pin(seq, at, "repeat", "warn");
+        break;
+      }
+      case "control.agent.narrowed-demanded": {
+        const flow = asString(payload.flow);
+        const nextFrame = asNumber(payload.nextFrame);
+        note(
+          seq,
+          "bad",
+          "narrowed",
+          bodyOf(
+            flow === void 0 ? void 0 : `${flow} ran narrower than the reading it stands in for.`,
+            nextFrame === void 0 ? void 0 : `Frame ${nextFrame}.`
+          ),
+          [clip(payload.broader), clip(payload.narrower)]
+        );
+        pin(seq, at, "narrowed", "bad");
+        break;
+      }
+      case "control.agent.unmoved-demanded": {
+        const nextFrame = asNumber(payload.nextFrame);
+        const opened = clip(payload.openedDigest);
+        const current = clip(payload.currentDigest);
+        note(
+          seq,
+          "bad",
+          "unmoved",
+          bodyOf(
+            "The tree the run opened on is the tree it closed on.",
+            nextFrame === void 0 ? void 0 : `Frame ${nextFrame}.`
+          ),
+          opened === void 0 || current === void 0 ? [] : [opened, current]
+        );
+        pin(seq, at, "unmoved", "bad");
+        break;
+      }
+      case "control.agent.unresolved-demanded": {
+        const flow = asString(payload.flow);
+        const nextFrame = asNumber(payload.nextFrame);
+        note(
+          seq,
+          "bad",
+          "unresolved",
+          bodyOf(
+            flow === void 0 ? void 0 : `${flow} failed and was not answered.`,
+            nextFrame === void 0 ? void 0 : `Frame ${nextFrame}.`
+          ),
+          [clip(payload.failed), clip(payload.instead)]
+        );
+        pin(seq, at, "unresolved", "bad");
+        break;
+      }
+      case "control.agent.claim-demanded": {
+        if (payload.demanded !== true && payload.refused !== true) break;
+        const complete = asNumber(payload.complete);
+        const overclaims = asNumber(payload.overclaims);
+        const nextFrame = asNumber(payload.nextFrame);
+        note(
+          seq,
+          "bad",
+          payload.refused === true ? "claim refused" : "claim",
+          bodyOf(
+            complete === void 0 || overclaims === void 0 ? void 0 : `complete ${complete}, overclaims ${overclaims}.`,
+            nextFrame === void 0 ? void 0 : `Frame ${nextFrame}.`
+          ),
+          []
+        );
+        pin(seq, at, payload.refused === true ? "claim refused" : "claim", "bad");
+        break;
+      }
+      /*
+       * The five kinds `AgentSession`'s `default` arm once journaled with
+       * `payload: {}`, however rich their `AgentEvent` schema was:
+       * cell-rejected-in-frame, read-only-demand-issued,
+       * narrow-only-demanded, steering-drained and sufficiency-observed.
+       * Their whole payload is late (`AgentSession` `lateFields`), so one
+       * record carries every field or none, and each arm below reads what its
+       * record has: a legacy record still folds, and still says nothing the
+       * record does not carry. A note with no body and no evidence is a title
+       * on its own, so a fieldless record writes none.
+       */
+      case "control.agent.cell-rejected-in-frame": {
+        const attempt = asNumber(payload.attempt);
+        const code = asString(payload.code);
+        const body = bodyOf(
+          code === void 0 ? void 0 : `${code}.`,
+          attempt === void 0 ? void 0 : `Attempt ${attempt}.`
+        );
+        if (body !== "") note(seq, "warn", "rejected", body, [clip(payload.message)]);
+        break;
+      }
+      case "control.agent.read-only-demand-issued": {
+        const streak = asNumber(payload.streak);
+        const cap = asNumber(payload.cap);
+        const nextFrame = asNumber(payload.nextFrame);
+        const body = bodyOf(
+          streak === void 0 || cap === void 0 ? void 0 : `${streak} of ${cap} frames changed nothing.`,
+          nextFrame === void 0 ? void 0 : `Frame ${nextFrame}.`
+        );
+        if (body !== "") note(seq, "warn", "read-only", body, []);
+        pin(seq, at, "read-only", "warn");
+        break;
+      }
+      case "control.agent.narrow-only-demanded": {
+        const flow = asString(payload.flow);
+        const targets = Array.isArray(payload.targets) ? payload.targets.filter((one) => typeof one === "string") : [];
+        const nextFrame = asNumber(payload.nextFrame);
+        const body = bodyOf(
+          flow === void 0 || targets.length === 0 ? void 0 : `${flow} ran on ${targets.join(", ")} and nothing broader.`,
+          nextFrame === void 0 ? void 0 : `Frame ${nextFrame}.`
+        );
+        if (body !== "") note(seq, "warn", "narrow-only", body, [clip(payload.check)]);
+        pin(seq, at, "narrow-only", "warn");
+        break;
+      }
+      case "control.agent.steering-drained": {
+        const messages = Array.isArray(payload.messages) ? payload.messages : [];
+        if (messages.length === 0) break;
+        note(
+          seq,
+          "warn",
+          "steering",
+          messages.length === 1 ? "1 steer." : `${messages.length} steers.`,
+          messages.map((message) => clip(asRecord(message).text))
+        );
+        pin(seq, at, "steering", "warn");
+        break;
+      }
+      case "control.agent.sufficiency-observed": {
+        const flow = asString(payload.flow);
+        const nextFrame = asNumber(payload.nextFrame);
+        const body = bodyOf(
+          flow === void 0 ? void 0 : `${flow} failed before the change and passed after it.`,
+          nextFrame === void 0 ? void 0 : `Frame ${nextFrame}.`
+        );
+        if (body !== "") note(seq, "good", "sufficiency", body, [clip(payload.failed), clip(payload.passed)]);
+        pin(seq, at, "sufficiency", "good");
+        break;
+      }
+      case "control.run.completed":
+      case "control.run.failed":
+      case "control.run.cancelled": {
+        const verdict = kind.slice("control.run.".length);
+        if (verdict === "cancelled") pin(seq, at, "stopped", "muted");
+        else pin(seq, at, verdict, verdict === "completed" ? "good" : "bad");
+        break;
+      }
+      default:
+        break;
+    }
+    owners.push({ seq, spanId: here() });
+  }
+  state.frame = frame;
+};
+const disciplineModel = (state) => {
+  const { frames, lastAt } = state;
+  const notes = state.notes.slice();
+  const milestones = state.milestones.slice();
+  const owners = state.owners.slice();
+  const changed = frames.map((entry) => entry.observedMutation ?? (entry.mutated === true || madeAWrite(entry)));
+  const firstSeen = /* @__PURE__ */ new Map();
+  const repeatedFrom = /* @__PURE__ */ new Map();
+  const redundant = [];
+  frames.forEach((entry, index) => {
+    const calls = entry.calls.filter((call) => call.flowName !== CHECKPOINT_FLOW);
+    for (const call of calls) {
+      if (call.settled === void 0) continue;
+      call.reading ??= `${call.signature} ${JSON.stringify(call.settled)}`;
+      const reading = call.reading;
+      const seen = firstSeen.get(reading);
+      if (seen === void 0) firstSeen.set(reading, entry.frame);
+      else if (seen < entry.frame) repeatedFrom.set(call, seen);
+    }
+    redundant.push(calls.length > 0 && calls.every((call) => repeatedFrom.has(call)));
+    if (changed[index] === true) firstSeen.clear();
+  });
+  const stalling = frames.map((_frame, index) => redundant[index] === true && changed[index] !== true);
+  const stuck = stalling.map((flag, index) => flag && (stalling[index - 1] === true || stalling[index + 1] === true));
+  const phases = frames.map(
+    (entry, index) => entry.blocked ? "blocked" : stuck[index] === true ? "stuck" : changed[index] === true || entry.calls.some((call) => call.activity === "writes") ? "implementing" : entry.calls.some((call) => call.activity === "checks" || call.activity === "tests") ? "testing" : entry.calls.some((call) => call.activity === "reads") ? "researching" : "unrecorded"
+  );
+  const bands = [];
+  frames.forEach((entry, index) => {
+    const phase = phases[index];
+    const endedAt = frames[index + 1]?.startedAt ?? Math.max(entry.endedAt, lastAt);
+    const last = bands[bands.length - 1];
+    if (last !== void 0 && last.phase === phase) {
+      bands[bands.length - 1] = { ...last, endedAt, frames: [...last.frames, entry.id] };
+      return;
+    }
+    bands.push({ phase, startedAt: entry.startedAt, endedAt, frames: [entry.id], seq: entry.seq });
+  });
+  const lines = frames.flatMap((entry, index) => {
+    const call = dominantCall(entry);
+    if (call === void 0) return [];
+    const repeatOf = stuck[index] === true ? repeatedFrom.get(call) : void 0;
+    const held = state.lineOf.get(entry);
+    if (held !== void 0 && held.call === call && held.settled === call.settled && held.repeatOf === repeatOf) {
+      return [held.line];
+    }
+    const outcome = call.settled === void 0 ? "pending" : call.settled.failed || call.settled.denied ? "failure" : "success";
+    const line = {
+      spanId: entry.id,
+      frame: entry.frame,
+      verb: call.presentation?.verb[outcome] ?? `${call.flowName}${outcome === "pending" ? " pending" : outcome === "failure" ? " failed" : ""}`,
+      subject: callSubject(call.input, call.presentation?.subject),
+      // Read supported output fields through the descriptor's presentation.
+      // The selected call retains the raw value, including unsupported shapes.
+      result: call.settled?.failed === true ? clip(call.settled.result) ?? "" : resultOf(call.settled?.value, call.presentation?.result),
+      failed: call.settled?.failed === true,
+      wrote: call.activity === "writes" && call.settled?.failed === false && !call.settled.denied,
+      ...repeatOf === void 0 ? {} : { repeatOf }
+    };
+    state.lineOf.set(entry, { call, settled: call.settled, repeatOf, line });
+    return [line];
+  });
+  return { bands, milestones, lines, notes, owners };
+};
+const isEngineRow = (record) => record.kind === "control.engine.event" || record.kind === "control.engine.projection-gap";
+const foldInit = (run) => ({
+  run,
+  root: builder(`run:${run.runId}`, "run", `run ${run.runId} \xB7 ${run.flowId}`, "running", 0, {
+    ...run.kind === void 0 ? {} : { fields: { kind: run.kind } }
+  }),
+  frame: void 0,
+  cell: void 0,
+  frames: 0,
+  calls: 0,
+  seat: void 0,
+  lastAt: 0,
+  count: 0,
+  verdict: void 0,
+  openCalls: [],
+  approvals: /* @__PURE__ */ new Map(),
+  discipline: disciplineInit(run.runId),
+  engine: [],
+  engineTrace: void 0,
+  frozen: /* @__PURE__ */ new WeakMap(),
+  dirty: /* @__PURE__ */ new Set(),
+  topOf: /* @__PURE__ */ new WeakMap()
+});
+const foldStep = (state, record) => {
+  if (isEngineRow(record)) {
+    state.engine.push(record);
+    state.engineTrace = void 0;
+  }
+  const { root, openCalls, approvals, dirty, topOf } = state;
+  let { frame, cell, frames, calls, seat } = state;
+  const top = frame ?? cell;
+  if (top !== void 0) dirty.add(top);
+  const touch = (span) => {
+    dirty.add(topOf.get(span));
+  };
+  const parent = () => cell ?? frame ?? root;
+  const closeCell = (at, status) => {
+    if (cell === void 0) return;
+    cell.endedAt = at;
+    cell.status = status;
+    cell = void 0;
+  };
+  const closeFrame = (at) => {
+    if (frame === void 0) return;
+    closeCell(at, cell?.children.some((child) => child.status === "failed") === true ? "failed" : "completed");
+    frame.endedAt = at;
+    frame.status = frame.children.some((child) => child.status === "failed") ? "failed" : "completed";
+    frame = void 0;
+  };
+  {
+    const kind = record.kind ?? "";
+    const payload = asRecord(record.payload);
+    const at = timeOf(record, payload);
+    if (state.count === 0) {
+      root.startedAt = at;
+      state.lastAt = at;
+    } else state.lastAt = Math.max(state.lastAt, at);
+    state.count += 1;
+    const opened = { sequence: record.sequence, event: kind };
+    switch (kind) {
+      case "control.engine.event":
+      case "control.engine.projection-gap":
+      case "control.engine.projection-started":
+      case "control.engine.projection-settled":
+        break;
+      case "control.agent.turn-opened": {
+        closeFrame(at);
+        frames += 1;
+        seat = asString(payload.seat) ?? seat;
+        frame = builder(
+          `frame-${frames}`,
+          "frame",
+          `frame ${frames}${seat === void 0 ? "" : ` \xB7 ${seat}`}`,
+          "running",
+          at,
+          {
+            ...opened,
+            ...seat === void 0 ? {} : { seat },
+            fields: restOf(payload, ["seat"])
+          }
+        );
+        root.children.push(frame);
+        break;
+      }
+      case "control.agent.model-settled": {
+        const usage = asRecord(payload.usage);
+        const duration = asNumber(payload.durationMillis);
+        const span = builder(
+          `model-${record.sequence ?? at}`,
+          "model",
+          "model",
+          "completed",
+          duration === void 0 ? at : at - duration,
+          {
+            ...opened,
+            ...seat === void 0 ? {} : { seat },
+            output: textOf(payload.text),
+            usage: { inputTokens: asNumber(usage.inputTokens), outputTokens: asNumber(usage.outputTokens) },
+            fields: restOf(payload, ["text", "usage", "durationMillis"])
+          }
+        );
+        span.endedAt = at;
+        (frame ?? root).children.push(span);
+        break;
+      }
+      case "control.agent.cell-produced": {
+        closeCell(at, "completed");
+        const language = asString(payload.language);
+        cell = builder(
+          `cell-${record.sequence ?? at}`,
+          "cell",
+          `cell${language === void 0 ? "" : ` \xB7 ${language}`}`,
+          "running",
+          at,
+          {
+            ...opened,
+            source: asString(payload.text),
+            fields: restOf(payload, ["text", "language"])
+          }
+        );
+        (frame ?? root).children.push(cell);
+        break;
+      }
+      case "control.agent.cell-call-started": {
+        calls += 1;
+        const recordedName = asString(payload.flowName);
+        const flowName = recordedName ?? `call-${calls}`;
+        const span = builder(`call-${calls}`, "call", (0, import_inspectLabels.inspectLabel)(flowName), "running", at, {
+          ...opened,
+          ...recordedName === void 0 ? {} : { flowName: recordedName },
+          input: payload.input,
+          fields: restOf(payload, ["flowName", "input"])
+        });
+        openCalls.push({ flowName, callId: asString(payload.callId), span });
+        topOf.set(span, frame ?? cell ?? span);
+        parent().children.push(span);
+        break;
+      }
+      case "control.agent.cell-call-settled": {
+        const index = (0, import_Diagnosis.openCallIndex)(openCalls, asString(payload.callId), asString(payload.flowName));
+        const settled = index < 0 ? void 0 : openCalls.splice(index, 1)[0];
+        if (settled === void 0) break;
+        const failed = asString(payload.outcome) === "failure";
+        touch(settled.span);
+        settled.span.endedAt = at;
+        settled.span.status = failed ? "failed" : "completed";
+        settled.span.detail = {
+          ...settled.span.detail,
+          ...failed ? { message: textOf(payload.message) } : { output: textOf(payload.value) },
+          ...!failed && settled.flowName === "agent/spawn" && asString(asRecord(payload.value).child) !== void 0 ? { childRunId: asString(asRecord(payload.value).child) } : {}
+        };
+        break;
+      }
+      case "control.agent.cell-printed": {
+        if (cell === void 0) {
+          parent().children.push(
+            builder(`printed-${record.sequence ?? at}`, "event", "printed", "completed", at, {
+              ...opened,
+              printed: textOf(payload.text)
+            })
+          );
+          break;
+        }
+        cell.detail = {
+          ...cell.detail,
+          printed: [cell.detail.printed, textOf(payload.text)].filter((text) => text !== void 0).join("\n")
+        };
+        break;
+      }
+      case "control.agent.cell-settled": {
+        closeCell(at, asString(payload.outcome) === "failure" ? "failed" : "completed");
+        break;
+      }
+      case "control.agent.resolved": {
+        const span = builder(`resolved-${record.sequence ?? at}`, "resolved", "resolved", "completed", at, {
+          ...opened,
+          output: textOf(payload.text)
+        });
+        span.endedAt = at;
+        (frame ?? root).children.push(span);
+        break;
+      }
+      case "control.approval.requested": {
+        const requestId = asString(payload.requestId) ?? `approval-${record.sequence ?? at}`;
+        const question = asString(payload.question);
+        const span = builder(
+          `approval-${requestId}`,
+          "approval",
+          `approval${question === void 0 ? "" : ` \xB7 ${question}`}`,
+          "waiting",
+          at,
+          {
+            ...opened,
+            fields: restOf(payload, ["question", "requestId", "payload", "runId"])
+          }
+        );
+        approvals.set(requestId, span);
+        topOf.set(span, frame ?? span);
+        (frame ?? root).children.push(span);
+        break;
+      }
+      case "control.approval.approved":
+      case "control.approval.denied": {
+        const decided = kind === "control.approval.approved" ? "approved" : "denied";
+        const key = asString(payload.tokenId) ?? asString(payload.requestId);
+        const span = key === void 0 ? [...approvals.values()].find((entry) => entry.status === "waiting") : approvals.get(key);
+        if (span === void 0) break;
+        touch(span);
+        span.status = decided;
+        span.endedAt = at;
+        break;
+      }
+      case "control.run.completed":
+      case "control.run.failed":
+      case "control.run.cancelled": {
+        closeFrame(at);
+        root.endedAt = at;
+        state.verdict = kind.slice("control.run.".length);
+        break;
+      }
+      default: {
+        if (!kind.startsWith("control.")) break;
+        const span = builder(
+          `event-${record.sequence ?? at}`,
+          "event",
+          kind.slice("control.".length),
+          "completed",
+          at,
+          {
+            ...opened,
+            fields: restOf(payload, [])
+          }
+        );
+        span.endedAt = at;
+        parent().children.push(span);
+        if (kind === "control.agent.turn-closed" && payload.step !== void 0) {
+          const closed = frame;
+          closeFrame(at);
+          if (closed !== void 0 && payload.outcome === "suspended") closed.status = "waiting";
+          if (closed !== void 0 && payload.outcome === "aborted") closed.status = "cancelled";
+        }
+      }
+    }
+  }
+  Object.assign(state, { frame, cell, frames, calls, seat });
+  const after = frame ?? cell;
+  if (after !== void 0) dirty.add(after);
+  disciplineStep(state.discipline, record);
+};
+const foldModel = (state, status, journal, engine) => {
+  const { root, frame, cell, lastAt } = state;
+  const closed = /* @__PURE__ */ new Map();
+  const statusOf = (node) => closed.get(node)?.status ?? node.status;
+  const terminal = TERMINAL_RUN.has(status);
+  if (terminal && frame !== void 0) {
+    if (cell !== void 0) {
+      closed.set(cell, {
+        status: cell.children.some((child) => child.status === "failed") ? "failed" : "completed",
+        endedAt: lastAt
+      });
+    }
+    closed.set(frame, {
+      status: frame.children.some((child) => statusOf(child) === "failed") ? "failed" : "completed",
+      endedAt: lastAt
+    });
+  }
+  if (engine === void 0 && state.engineTrace === void 0) state.engineTrace = (0, import_EngineTrace.engineTraceFromJournal)(state.engine);
+  const children = [...root.children, ...engine ?? state.engineTrace];
+  closed.set(root, {
+    status: state.verdict ?? status,
+    endedAt: root.endedAt ?? (terminal && state.count > 0 ? lastAt : Number.NaN)
+  });
+  const freeze = (node, depth, members) => freezeWith(node, depth, members.map((child) => freeze(child, depth + 1, child.children)));
+  const freezeWith = (node, depth, frozenChildren2) => {
+    const override = closed.get(node);
+    const nodeStatus = override?.status ?? node.status;
+    const endedAt = override === void 0 || Number.isNaN(override.endedAt) ? node.endedAt : override.endedAt;
+    const held = state.frozen.get(node);
+    if (held !== void 0 && held.depth === depth && held.label === node.label && held.status === nodeStatus && held.startedAt === node.startedAt && held.endedAt === endedAt && held.detail === node.detail && held.children.length === frozenChildren2.length && held.children.every((child, index) => child === frozenChildren2[index])) return held;
+    const span = {
+      id: node.id,
+      kind: node.kind,
+      label: node.label,
+      status: nodeStatus,
+      startedAt: node.startedAt,
+      ...endedAt === void 0 ? {} : { endedAt },
+      depth,
+      children: frozenChildren2,
+      detail: node.detail
+    };
+    state.frozen.set(node, span);
+    return span;
+  };
+  const settledChild = (child) => {
+    if (state.dirty.has(child) || closed.has(child)) return void 0;
+    const held = state.frozen.get(child);
+    return held?.depth === 1 ? held : void 0;
+  };
+  const frozenChildren = children.map((child) => settledChild(child) ?? freeze(child, 1, child.children));
+  state.dirty.clear();
+  const frozenRoot = freezeWith(root, 0, frozenChildren);
+  const rows = [];
+  const walk = (span) => {
+    rows.push(span);
+    for (const child of span.children) walk(child);
+  };
+  walk(frozenRoot);
+  let start = Number.POSITIVE_INFINITY;
+  let end = 0;
+  let running = 0;
+  let failed = 0;
+  for (const span of rows) {
+    start = Math.min(start, span.startedAt);
+    end = Math.max(end, span.endedAt ?? span.startedAt);
+    if (span.kind !== "run" && span.status === "running") running += 1;
+    if (span.kind !== "run" && span.status === "failed") failed += 1;
+  }
+  const extent = state.count === 0 || !Number.isFinite(start) ? { start: 0, end: 0 } : { start, end: Math.max(end, start) };
+  return {
+    journal,
+    root: frozenRoot,
+    rows,
+    extent,
+    counts: { spans: rows.length - 1, running, failed },
+    ...disciplineModel(state.discipline)
+  };
+};
+const sequenceOf = (record) => record.sequence ?? 0;
+const TERMINAL_KINDS = /* @__PURE__ */ new Set([
+  "control.run.completed",
+  "control.run.failed",
+  "control.run.cancelled"
+]);
+const route = (state, record) => {
+  if (record.kind?.startsWith("control.run.") === true && record.runId !== void 0 && record.runId !== state.run.runId) {
+    return;
+  }
+  state.firstAt = Math.min(state.firstAt, timeOf(record, asRecord(record.payload)));
+  if (TERMINAL_KINDS.has(record.kind ?? "")) state.terminal = record;
+  const scope = (0, import_Diagnosis.callScope)(record);
+  if (scope === void 0) return foldStep(state.base, record);
+  let group = state.groups.get(scope);
+  if (group === void 0) {
+    group = foldInit(state.run);
+    state.groups.set(scope, group);
+  }
+  foldStep(group, record);
+};
+const reseed = (state, arrived) => {
+  const journal = [...arrived].sort((left, right) => sequenceOf(left) - sequenceOf(right));
+  const filter = (0, import_callEvents.callEventFilter)();
+  for (const record of journal) filter.push(record);
+  Object.assign(state, {
+    arrived,
+    journal,
+    filter,
+    base: foldInit(state.run),
+    groups: /* @__PURE__ */ new Map(),
+    engine: journal.filter(isEngineRow),
+    engineTrace: void 0,
+    firstAt: Number.POSITIVE_INFINITY,
+    terminal: void 0,
+    memo: void 0
+  });
+  for (const record of (0, import_callEvents.uniqueCallEvents)(journal)) route(state, record);
+};
+const traceFold = (run, records = []) => {
+  const state = {
+    run: { runId: run.runId, flowId: run.flowId, ...run.kind === void 0 ? {} : { kind: run.kind } }
+  };
+  state.source = void 0;
+  reseed(state, [...records]);
+  return state;
+};
+const traceFoldStep = (fold, record) => {
+  const state = fold;
+  state.memo = void 0;
+  state.arrived.push(record);
+  const last = state.journal.at(-1);
+  if (last !== void 0 && !(sequenceOf(record) >= sequenceOf(last))) {
+    reseed(state, state.arrived);
+    return fold;
+  }
+  state.journal.push(record);
+  if (isEngineRow(record)) {
+    state.engine.push(record);
+    state.engineTrace = void 0;
+  }
+  const verdict = state.filter.push(record);
+  if (verdict._tag === "rewrite") reseed(state, state.arrived);
+  else if (verdict._tag === "keep") route(state, verdict.event);
+  return fold;
+};
+const traceFoldSync = (fold, run, records) => {
+  const held = fold;
+  const source = held?.source;
+  const extends_ = held !== void 0 && source !== void 0 && held.run.runId === run.runId && held.run.flowId === run.flowId && held.run.kind === run.kind && records.length >= source.length && source.every((record, index) => records[index] === record);
+  const next = extends_ ? held : traceFold(run);
+  for (let index = extends_ ? source.length : 0; index < records.length; index++) traceFoldStep(next, records[index]);
+  next.source = records.slice();
+  return next;
+};
+const traceFoldModel = (fold, status) => {
+  const state = fold;
+  if (state.memo?.status === status) return state.memo.model;
+  const model = mergeModel(state, status);
+  state.memo = { status, model };
+  return model;
+};
+const mergeModel = (state, status) => {
+  const journal = state.journal.slice();
+  if (state.groups.size === 0) {
+    if (state.engineTrace === void 0) state.engineTrace = (0, import_EngineTrace.engineTraceFromJournal)(state.engine);
+    return foldModel(state.base, status, journal, state.engineTrace);
+  }
+  const base = foldModel(state.base, status, journal);
+  const children = [...base.root.children];
+  const bands = [...base.bands];
+  const milestones = [...base.milestones];
+  const lines = [...base.lines];
+  const notes = [...base.notes];
+  const owners = [...base.owners];
+  const terminal = state.terminal;
+  const terminalAt = terminal === void 0 ? void 0 : timeOf(terminal, asRecord(terminal.payload));
+  for (const [scope, group] of state.groups) {
+    const prefix = `step:${encodeURIComponent(scope)}/`;
+    const scoped = foldModel(group, "running", journal);
+    const rename = (span) => ({
+      ...span,
+      id: `${prefix}${span.id}`,
+      children: span.children.map(rename),
+      ...span.status === "running" && TERMINAL_RUN.has(base.root.status) ? {
+        // A terminal run proves work stopped. It does not prove which open
+        // step succeeded or caused the run to fail.
+        status: "stopped",
+        ...terminalAt === void 0 ? {} : { endedAt: terminalAt }
+      } : {}
+    });
+    children.push(...scoped.root.children.map(rename));
+    bands.push(...scoped.bands.map((band) => ({ ...band, frames: band.frames.map((id) => `${prefix}${id}`) })));
+    const owned = (spanId) => spanId === scoped.root.id ? base.root.id : `${prefix}${spanId}`;
+    milestones.push(...scoped.milestones.map((one) => ({ ...one, spanId: owned(one.spanId) })));
+    lines.push(...scoped.lines.map((line) => ({ ...line, spanId: `${prefix}${line.spanId}` })));
+    notes.push(...scoped.notes.map((note) => ({ ...note, spanId: owned(note.spanId) })));
+    owners.push(...scoped.owners.map((one) => ({ ...one, spanId: owned(one.spanId) })));
+  }
+  children.sort(
+    (left, right) => left.startedAt - right.startedAt || (left.detail.sequence ?? 0) - (right.detail.sequence ?? 0)
+  );
+  const root = { ...base.root, startedAt: state.firstAt, children };
+  const rows = [];
+  const walk = (span) => {
+    rows.push(span);
+    span.children.forEach(walk);
+  };
+  walk(root);
+  const positions = new Map(rows.map((span, index) => [span.id, index]));
+  const merged = lines.sort((left, right) => positions.get(left.spanId) - positions.get(right.spanId));
+  const stepOf = (spanId) => spanId.slice(0, spanId.lastIndexOf("/") + 1);
+  const renumbered = new Map(merged.map((line, index) => [`${stepOf(line.spanId)}${line.frame}`, index + 1]));
+  let start = Number.POSITIVE_INFINITY;
+  let end = Number.NEGATIVE_INFINITY;
+  for (const span of rows) {
+    start = Math.min(start, span.startedAt);
+    end = Math.max(end, span.endedAt ?? span.startedAt);
+  }
+  return {
+    journal,
+    root,
+    rows,
+    extent: { start, end },
+    counts: {
+      spans: rows.length - 1,
+      running: rows.filter((span) => span.kind !== "run" && span.status === "running").length,
+      failed: rows.filter((span) => span.kind !== "run" && span.status === "failed").length
+    },
+    bands: bands.sort((left, right) => left.startedAt - right.startedAt || left.seq - right.seq),
+    milestones: milestones.sort((left, right) => left.seq - right.seq),
+    lines: merged.map((line, index) => ({
+      ...line,
+      frame: index + 1,
+      ...line.repeatOf === void 0 ? {} : { repeatOf: renumbered.get(`${stepOf(line.spanId)}${line.repeatOf}`) }
+    })),
+    notes: notes.sort((left, right) => left.seq - right.seq),
+    owners: owners.sort((left, right) => left.seq - right.seq)
+  };
+};
+const traceFromJournal = (run, records, _options = {}) => traceFoldModel(traceFold(run, records), run.status);
+const waterfallGeometry = (span, extent) => {
+  const width = Math.max(extent.end - extent.start, 1);
+  const from = span.startedAt;
+  const to = span.endedAt ?? extent.end;
+  const left = (from - extent.start) / width * 100;
+  const bar = Math.max((to - from) / width * 100, 0);
+  return { left: Math.round(left * 100) / 100, width: Math.round(bar * 100) / 100 };
+};
+const phaseExtent = (model) => {
+  return model.bands.length === 0 ? model.extent : {
+    start: Math.min(...model.bands.map((band) => band.startedAt)),
+    end: Math.max(...model.bands.map((band) => band.endedAt))
+  };
+};
+const phaseBandGeometry = (band, extent, index, count) => {
+  const round = (value) => Math.round(value * 100) / 100;
+  const axis = extent.end - extent.start;
+  if (axis <= 0) {
+    const share = 100 / Math.max(count, 1);
+    return { left: round(index * share), width: round(share) };
+  }
+  return {
+    left: round((band.startedAt - extent.start) / axis * 100),
+    width: round(Math.max(band.endedAt - band.startedAt, 0) / axis * 100)
+  };
+};
+const MESSAGE_FLOWS = /* @__PURE__ */ new Set(["agent/send", "agent/await"]);
+const spanMatches = (span, filter) => {
+  const own = filter === "all" ? true : filter === "running" ? span.status === "running" || span.status === "waiting" : filter === "failed" ? span.status === "failed" : filter === "model" ? span.kind === "model" : filter === "flow" ? span.kind === "call" || span.kind === "execution" || span.kind === "attempt" : span.kind === "call" && MESSAGE_FLOWS.has(span.label);
+  return own || span.children.some((child) => spanMatches(child, filter));
+};
+const TRACE_FILTER_IDS = [
+  "all",
+  "running",
+  "failed",
+  "model",
+  "flow",
+  "messages"
+];
+const FILTER_LABELS = {
+  all: "all",
+  running: "running",
+  failed: "failed",
+  model: "model calls",
+  flow: "flow calls",
+  messages: "messages"
+};
+const traceFiltersFor = (kind) => (kind === "prototype" ? ["all", "messages", "failed"] : ["all", "running", "failed", "model", "flow"]).map((id) => [id, FILTER_LABELS[id]]);
+const isTraceFilter = (value) => TRACE_FILTER_IDS.includes(value);
+const proseLine = (text) => {
+  if (text === void 0) return void 0;
+  let fence;
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    const marker = /^(?:`{3,}|~{3,})/.exec(trimmed)?.[0];
+    if (marker !== void 0) {
+      if (fence === void 0) fence = marker;
+      else if (marker[0] === fence[0] && marker.length >= fence.length) fence = void 0;
+      continue;
+    }
+    if (fence !== void 0 || trimmed === "") continue;
+    if (/^(?:[[{]|(?:const|let|var|await|import|export|function|return)\b)/.test(trimmed)) return void 0;
+    const words = trimmed.replace(/^#{1,6}\s+|^[-*+]\s+|^>\s+/, "").replace(/\s+/g, " ");
+    const sentence = words.match(/^.*?[.!?](?=\s|$)/)?.[0] ?? `${words}.`;
+    return sentence.length <= 180 ? sentence : `${sentence.slice(0, 179).trimEnd()}\u2026`;
+  }
+  return void 0;
+};
+const turnNarratives = (model) => model.root.children.filter((span) => span.kind === "frame").map((frame, index) => {
+  const text = frame.children.filter((span) => span.kind === "model").map((span) => proseLine(span.detail.output)).find((value) => value !== void 0);
+  if (text !== void 0) return { frame, number: index + 1, text, source: "model" };
+  const names = [];
+  const walk = (span) => {
+    if (span.kind === "call" && !names.includes(span.label)) names.push(span.label);
+    for (const child of span.children) walk(child);
+  };
+  walk(frame);
+  return names.length > 0 ? {
+    frame,
+    number: index + 1,
+    text: `The agent called ${names.slice(0, 3).join(", ")}${names.length > 3 ? ` and ${names.length - 3} other flows` : ""}.`,
+    source: "calls"
+  } : {
+    frame,
+    number: index + 1,
+    text: frame.children.some((span) => span.kind === "cell") ? "The agent produced a script; no flow calls were recorded in this turn." : frame.children.some((span) => span.kind === "model") ? "The model responded; no script or flow calls were recorded in this turn." : "The turn started; no model response or flow calls have been recorded.",
+    source: "journal"
+  };
+});
+const spanPath = (model, id) => {
+  const visit = (span) => {
+    if (span.id === id) return [span];
+    for (const child of span.children) {
+      const path = visit(child);
+      if (path !== void 0) return [span, ...path];
+    }
+    return void 0;
+  };
+  return visit(model.root) ?? [model.root];
+};
+const durationWords = (ms) => {
+  if (ms < 1e3) return `${Math.round(ms)}ms`;
+  if (ms < 59950) return `${(ms / 1e3).toFixed(1)}s`;
+  const total = Math.round(ms / 1e3);
+  if (total < 3600) {
+    const minutes2 = Math.floor(total / 60);
+    return `${minutes2}m${String(total - minutes2 * 60).padStart(2, "0")}s`;
+  }
+  const minutes = Math.round(ms / 6e4);
+  const hours = Math.floor(minutes / 60);
+  return `${hours}h${String(minutes - hours * 60).padStart(2, "0")}m`;
+};
+const memoryItems = (value) => Array.isArray(value) ? value.flatMap((raw) => {
+  const item = typeof raw === "object" && raw !== null ? raw : void 0;
+  return item?.kind === "memory" && typeof item.id === "string" && typeof item.p === "number" ? [{ id: item.id, kind: "memory", relevance: 1 - item.p }] : [];
+}) : [];
+const runMemoryOf = (records) => {
+  const kept = /* @__PURE__ */ new Map();
+  const withheld = /* @__PURE__ */ new Map();
+  let read = false;
+  for (const record of records) {
+    if (record.kind !== "control.agent.relevance-settled") continue;
+    const payload = typeof record.payload === "object" && record.payload !== null ? record.payload : {};
+    if (!Array.isArray(payload.kept) && !Array.isArray(payload.withheld)) continue;
+    read = true;
+    for (const item of memoryItems(payload.kept)) kept.set(item.id, item);
+    for (const item of memoryItems(payload.withheld)) withheld.set(item.id, item);
+  }
+  if (!read) return void 0;
+  const byRelevance = (left, right) => right.relevance - left.relevance || left.id.localeCompare(right.id);
+  return {
+    kept: [...kept.values()].sort(byRelevance),
+    withheld: [...withheld.values()].filter((item) => !kept.has(item.id)).sort(byRelevance)
+  };
+};
+const TASK_PREFIX = "The task for this run:\n\n";
+const taskOf = (request) => {
+  const parts = Array.isArray(request.system) ? request.system : [];
+  const part = parts.find((text) => typeof text === "string" && text.startsWith(TASK_PREFIX));
+  const task = typeof request.task === "string" ? request.task : part?.slice(TASK_PREFIX.length);
+  if (task === void 0) return void 0;
+  try {
+    return JSON.parse(task);
+  } catch {
+    return task;
+  }
+};
+const hexDigest = /^[0-9a-f]{64}$/;
+const cellText = (value) => {
+  const text = textOf(value);
+  return text === void 0 || text.length <= 2e3 ? text : `${text.slice(0, 2e3)}\u2026`;
+};
+const callCellLabel = (started, failed) => {
+  const descriptor = asRecord(started.descriptor);
+  const presentation = asRecord(descriptor.presentation);
+  const verbs = asRecord(presentation.verb);
+  const name = started.flowName;
+  const verb = asString(failed ? verbs.failure : verbs.success) ?? (failed ? `failed ${name}` : name);
+  const subjectKey = asString(presentation.subject);
+  const subject = subjectKey === void 0 ? void 0 : asString(asRecord(started.input)[subjectKey]);
+  const text = subject === void 0 ? verb : `${verb} ${subject}`;
+  return text.charAt(0).toUpperCase() + text.slice(1);
+};
+const callCellKind = (started) => {
+  const activity = asString(asRecord(started.descriptor).activity);
+  const name = started.flowName;
+  return name === "ask" ? "ask" : activity === "reads" ? "read" : activity === "writes" ? "edit" : "run";
+};
+const decodeCallFact = import_effect.Schema.decodeUnknownOption(import_journal.CallFact.Fact);
+const callFactOf = (record) => {
+  if (record.kind !== "control.engine.event") return void 0;
+  const envelope = asRecord(record.payload);
+  if (envelope.version !== 1 || envelope.eventType !== import_journal.CallFact.eventType || envelope.sourceSequence !== 0) {
+    return void 0;
+  }
+  const fact = decodeCallFact(envelope.payload);
+  if (fact._tag === "None" || envelope.sourceId !== `call-fact-v1:${fact.value.callId}:${fact.value.phase}`) {
+    return void 0;
+  }
+  const stepId = /@([0-9a-f]{64}):\d+#\d+$/.exec(fact.value.identity.runId)?.[1];
+  return stepId === void 0 ? void 0 : { stepId, fact: fact.value };
+};
+const stepTranscripts = (journal) => {
+  const transcripts = /* @__PURE__ */ new Map();
+  const entry = (key) => {
+    let found = transcripts.get(key);
+    if (found === void 0) transcripts.set(key, found = { cells: [], tokens: 0, models: 0 });
+    return found;
+  };
+  const lastCell = /* @__PURE__ */ new Map();
+  const calls = /* @__PURE__ */ new Map();
+  for (const record of journal) {
+    const sequence = record.sequence ?? 0;
+    const step = (0, import_callEvents.nativeStepEvent)(record);
+    if (step !== void 0) {
+      const payload = asRecord(step.payload);
+      const stepId = asString(asRecord(payload.step).stepId);
+      const transcript = entry(stepId);
+      if (step.kind === "control.agent.model-requested" && transcript.input === void 0) {
+        const task = taskOf(payload);
+        if (task !== void 0) transcript.input = task;
+      } else if (step.kind === "control.agent.model-settled") {
+        const usage = asRecord(payload.usage);
+        const tokens = (asNumber(usage.inputTokens) ?? 0) + (asNumber(usage.outputTokens) ?? 0);
+        const duration = asNumber(payload.durationMillis);
+        const text = cellText(payload.text);
+        transcript.tokens += tokens;
+        transcript.models += 1;
+        transcript.cells.push({
+          id: `cell:${sequence}`,
+          kind: "think",
+          label: "Model reply",
+          ...text === void 0 ? {} : { quote: text },
+          tokens,
+          ...duration === void 0 ? {} : { took_s: Math.max(0, duration) / 1e3 }
+        });
+      } else if (step.kind === "control.agent.cell-produced") {
+        const code = cellText(payload.text);
+        const cell = {
+          id: `cell:${sequence}`,
+          kind: "run",
+          label: "Ran a cell",
+          ...code === void 0 ? {} : { code }
+        };
+        transcript.cells.push(cell);
+        lastCell.set(stepId, cell);
+      } else if (step.kind === "control.agent.cell-printed") {
+        const cell = lastCell.get(stepId);
+        const printed = cellText(payload.text);
+        if (cell !== void 0 && printed !== void 0 && printed !== "") {
+          cell.output = cell.output === void 0 ? printed : `${cell.output}
+${printed}`;
+        }
+      } else if (step.kind === "control.agent.cell-settled") {
+        const cell = lastCell.get(stepId);
+        if (cell !== void 0) cell.tone = asString(payload.outcome) === "failure" ? "fail" : "ok";
+      }
+      continue;
+    }
+    const call = callFactOf(record);
+    if (call === void 0) continue;
+    const handle = `${call.stepId}:${call.fact.callId}`;
+    if (call.fact.phase === "invoked") {
+      const input = cellText(call.fact.input);
+      const cell = {
+        id: `cell:${sequence}`,
+        kind: callCellKind(call.fact),
+        label: callCellLabel(call.fact, false),
+        ...input === void 0 ? {} : { code: input },
+        tone: "live"
+      };
+      entry(call.stepId).cells.push(cell);
+      calls.set(handle, { cell, started: call.fact });
+      continue;
+    }
+    const open = calls.get(handle);
+    if (open === void 0) continue;
+    const failed = call.fact.outcome === "failure";
+    open.cell.label = callCellLabel(open.started, failed);
+    open.cell.tone = failed ? "fail" : "ok";
+    const result = failed ? cellText(call.fact.message) : cellText(call.fact.value);
+    if (result !== void 0) open.cell.output = result;
+  }
+  return transcripts;
+};
+const nodeDispatches = (row) => {
+  if (!row.id.startsWith("engine-node:")) return [];
+  const fields = asRecord(row.detail.fields);
+  const execution = asString(fields.executionId);
+  const digests = asRecord(fields.payload).stepKeyDigests;
+  if (execution === void 0 || !Array.isArray(digests)) return [];
+  return [
+    ...new Set(digests.filter((digest) => typeof digest === "string" && hexDigest.test(digest)))
+  ].map((digest) => `${execution}:${digest}`);
+};
+const PLAN_STRUCTURE = /* @__PURE__ */ new Set([
+  "Succeed",
+  "Fail",
+  "All",
+  "Race",
+  "Map",
+  "AndThen",
+  "Branch",
+  "Catch",
+  "FlowCall",
+  "FunctionIdentity",
+  "PlannedReference"
+]);
+const RECEIPT_HEAD = /^\{"checkId":"[^"\\]*"(?:,"[A-Za-z]+":(?:"[^"\\]*"|-?\d+))*,"status":"(passed|failed|superseded)"/;
+const checkFailures = (output) => {
+  if (output === void 0) return 0;
+  const head = RECEIPT_HEAD.exec(output);
+  if (head !== null) return head[1] === "failed" ? 1 : 0;
+  let value;
+  try {
+    value = JSON.parse(output);
+  } catch {
+    return 0;
+  }
+  return (Array.isArray(value) ? value : []).filter((receipt) => {
+    const record = asRecord(receipt);
+    return typeof record.checkId === "string" && record.status === "failed";
+  }).length;
+};
+const engineNodeShapes = (journal) => {
+  const shapes = /* @__PURE__ */ new Map();
+  for (const record of journal) {
+    if (record.kind !== "control.engine.event") continue;
+    const envelope = asRecord(record.payload);
+    const executionId = asString(envelope.executionId);
+    const generation = asNumber(envelope.generation);
+    const payload = asRecord(envelope.payload);
+    if (executionId === void 0 || generation === void 0) continue;
+    const prefix = `engine-node:${encodeURIComponent(`${encodeURIComponent(executionId)}:${generation}`)}:`;
+    if (envelope.eventType === "flows.engine.plan-recorded" || envelope.eventType === "flows.engine.subgraph-appended") {
+      const nodes = asRecord(payload.graph).nodes;
+      for (const node of Array.isArray(nodes) ? nodes : []) {
+        const shape = asRecord(node);
+        const id = asString(shape.id);
+        if (id !== void 0) {
+          shapes.set(prefix + encodeURIComponent(id), { kind: asString(shape.kind), action: asString(shape.action) });
+        }
+      }
+    } else if (envelope.eventType === "flows.engine.node-scheduled") {
+      const id = asString(payload.nodeId);
+      if (id === void 0) continue;
+      const known = shapes.get(prefix + encodeURIComponent(id));
+      shapes.set(prefix + encodeURIComponent(id), {
+        kind: asString(payload.kind) ?? known?.kind,
+        action: asString(payload.action) ?? known?.action
+      });
+    }
+  }
+  return shapes;
+};
+const monitorFromJournal = (run, records, at) => {
+  const last = records.reduce((last2, row) => Math.max(last2, row.sequence ?? 0), 0);
+  const journal = at === void 0 ? records : records.filter((row) => (row.sequence ?? 0) <= at);
+  const lifecycleRow = [...journal].reverse().find(
+    (row) => /^control\.run\.(running|waiting-approval|paused|suspended|held|completed|failed|cancelled|interrupted)$/.test(
+      row.kind ?? ""
+    ) && (row.runId === void 0 || row.runId === run.runId)
+  );
+  const status = at === void 0 ? run.status : lifecycleRow?.kind?.split(".").at(-1) ?? "running";
+  const state = (value) => value === "completed" || value === "done" ? "done" : value === "failed" ? "failed" : value === "cancelled" || value === "interrupted" ? "interrupted" : value === "held" ? "held" : value === "waiting" || value === "waiting-approval" || value === "paused" || value === "suspended" ? "waiting" : "running";
+  const trace = traceFromJournal({ ...run, status }, journal);
+  const engineLabel = (label) => import_actionRenderings.ACTION_RENDERINGS[label] === null || /^<(?:boundary:|quota-park>|structured-output-count>)/.test(label);
+  const bookkeeping = (row) => engineLabel(row.label);
+  const transcripts = stepTranscripts(journal);
+  const dispatchesOf = new Map(trace.rows.map((row) => [row.id, nodeDispatches(row)]));
+  const structural = (kind) => kind !== void 0 && PLAN_STRUCTURE.has(kind);
+  const nodeShapes = engineNodeShapes(journal);
+  const calls = trace.rows.filter((row) => {
+    if (row.kind !== "call" || bookkeeping(row) || row.id.startsWith("step:")) return false;
+    const shape = nodeShapes.get(row.id.replace(/#\d+$/, ""));
+    return shape === void 0 || !structural(shape.kind);
+  });
+  const transcriptOf = (row) => {
+    const parts = dispatchesOf.get(row.id).flatMap((dispatch) => {
+      const found = transcripts.get(dispatch.slice(dispatch.lastIndexOf(":") + 1));
+      return found === void 0 ? [] : [found];
+    });
+    return {
+      cells: parts.flatMap((part) => part.cells).sort(
+        (left, right) => Number(left.id.slice(5)) - Number(right.id.slice(5))
+      ),
+      tokens: parts.reduce((total, part) => total + part.tokens, 0),
+      models: parts.reduce((total, part) => total + part.models, 0),
+      input: parts.find((part) => part.input !== void 0)?.input
+    };
+  };
+  const steps = calls.map((row) => {
+    const meter = dispatchesOf.get(row.id);
+    const transcript = transcriptOf(row);
+    return {
+      ...(() => {
+        const matched = /^(engine-node:.*)#(\d+)$/.exec(row.id);
+        const id = matched?.[1] ?? row.id;
+        const k = Number(matched?.[2] ?? 1);
+        return { key: `${id}#${k}`, id, k };
+      })(),
+      label: row.label,
+      state: row.status,
+      started_at: new Date(row.startedAt).toISOString(),
+      ...row.endedAt === void 0 ? {} : { ended_at: new Date(row.endedAt).toISOString(), took_s: Math.max(0, row.endedAt - row.startedAt) / 1e3 },
+      ...row.detail.input !== void 0 ? { input: row.detail.input } : transcript.input !== void 0 ? { input: transcript.input } : {},
+      ...row.detail.output === void 0 ? {} : { output: row.detail.output },
+      // The install prices these dispatches from its metered proxy rows and
+      // replaces them with `usage`; the journal's own token count rides along.
+      ...meter.length === 0 ? {} : { meter },
+      ...transcript.models === 0 ? {} : { model_calls: transcript.models, tokens: transcript.tokens }
+    };
+  });
+  const tone = (value) => value === "failed" ? "fail" : value === "completed" ? "ok" : value === "waiting" ? "wait" : "live";
+  const phases = calls.map((row, index) => {
+    const transcript = transcriptOf(row).cells;
+    const failedChecks = checkFailures(row.detail.output);
+    const cells = transcript.length > 0 ? transcript : [{
+      id: `cell:${row.id}`,
+      kind: /Edited/.test(row.label) ? "edit" : /Read/.test(row.label) ? "read" : "run",
+      label: row.label,
+      ...row.detail.output === void 0 ? {} : { output: row.detail.output },
+      tone: tone(row.status)
+    }];
+    return {
+      id: `phase:${row.id}`,
+      step: steps[index].key,
+      // The title is the Appendix C label plus the outcome its recorded
+      // output reports: "Ran checks · 1 failed".
+      title: failedChecks === 0 ? row.label : `${row.label} \xB7 ${failedChecks} failed`,
+      took_s: Math.max(0, (row.endedAt ?? row.startedAt) - row.startedAt) / 1e3,
+      tone: failedChecks === 0 ? tone(row.status) : "fail",
+      cells
+    };
+  });
+  const declaredGraph = (0, import_EngineTrace.engineExecutionEvidence)(journal).filter((execution) => execution.coherent).flatMap(
+    (execution) => {
+      const prefix = `engine-node:${encodeURIComponent(`${encodeURIComponent(execution.executionId)}:${execution.generation}`)}:`;
+      const nodes = execution.graph?.nodes ?? [];
+      const hidden = new Map(
+        nodes.filter((node) => engineLabel(node.action ?? node.id) || structural(node.kind)).map((node) => [node.id, node])
+      );
+      const visibleDeps = (id, seen) => {
+        const node = hidden.get(id);
+        if (node === void 0) return [prefix + encodeURIComponent(id)];
+        if (seen.has(id)) return [];
+        return node.dependsOn.flatMap((dependency) => visibleDeps(dependency, /* @__PURE__ */ new Set([...seen, id])));
+      };
+      return nodes.filter((node) => !hidden.has(node.id)).map((node) => {
+        const id = prefix + encodeURIComponent(node.id);
+        const instances = calls.filter((row) => row.id.startsWith(`${id}#`));
+        const current = instances.at(-1);
+        return {
+          id,
+          label: (0, import_inspectLabels.inspectLabel)(node.action ?? node.id),
+          // A branch not taken never ran: it stays next, even in a finished run.
+          state: current === void 0 || current.status === "skipped" ? "next" : current.status === "completed" ? "done" : current.status === "failed" ? "failed" : current.status === "waiting" ? "waiting" : "current",
+          deps: [...new Set(node.dependsOn.flatMap((dependency) => visibleDeps(dependency, /* @__PURE__ */ new Set([node.id]))))]
+        };
+      });
+    }
+  );
+  const usageOf = (row) => (row.detail.usage?.inputTokens ?? 0) + (row.detail.usage?.outputTokens ?? 0);
+  const tokens = trace.rows.reduce((total, row) => total + usageOf(row), 0);
+  const unmetered = trace.rows.filter((row) => row.kind === "model" && asRecord(row.detail.fields).step === void 0).reduce((total, row) => total + usageOf(row), 0);
+  const approvalWaits = trace.rows.filter((row) => row.kind === "approval").map((row) => ({
+    id: row.id,
+    kind: "approval",
+    label: row.label,
+    since: new Date(row.startedAt).toISOString(),
+    ...row.endedAt === void 0 ? {} : {
+      settled: { by: { kind: "system", color_index: 7 }, at: new Date(row.endedAt).toISOString() }
+    }
+  }));
+  const custom = [...journal].reverse().find((row) => (row.runId === void 0 || row.runId === run.runId) && row.kind === "control.engine.event" && asRecord(row.payload).eventType === "flows.run.presentation");
+  const presentation = asRecord(asRecord(custom?.payload).payload);
+  const text = asString(presentation.text);
+  const customView = presentation.kind === "text" && text !== void 0 && text.length <= 65536 && Object.keys(presentation).every((key) => key === "kind" || key === "text") ? { presentation: { kind: "text", text } } : {};
+  return {
+    ...customView,
+    id: run.runId,
+    flow: run.flowId,
+    version: "",
+    title: run.flowId,
+    state: state(status),
+    attempts: [{
+      n: 1,
+      run_id: run.runId,
+      state: state(status),
+      steps,
+      phases,
+      graph: declaredGraph.length > 0 ? declaredGraph : calls.map((row) => ({
+        id: row.id,
+        label: row.label,
+        state: row.status === "skipped" ? "next" : row.status === "completed" ? "done" : row.status === "failed" ? "failed" : row.status === "waiting" ? "waiting" : "current",
+        deps: []
+      }))
+    }],
+    waits: [
+      ...approvalWaits,
+      ...(0, import_EngineTrace.engineExecutionEvidence)(journal).filter((execution) => execution.coherent).flatMap(
+        (execution) => execution.waits.map((wait) => ({
+          id: wait.id,
+          kind: wait.kind,
+          label: (0, import_inspectLabels.inspectLabel)("wait"),
+          since: new Date(wait.since).toISOString(),
+          ...wait.settledAt === void 0 ? {} : {
+            settled: {
+              by: { kind: "system", color_index: 7 },
+              at: new Date(wait.settledAt).toISOString()
+            }
+          }
+        }))
+      )
+    ],
+    tokens,
+    // Spend is priced where model calls are metered. The host never publishes
+    // an unknown total as zero: a run with model tokens leaves cost to the install.
+    time_s: Math.max(0, trace.extent.end - trace.extent.start) / 1e3,
+    ...tokens === 0 ? { cost_usd: 0 } : {},
+    ...unmetered === 0 ? {} : { unmetered_tokens: unmetered },
+    engine: trace.rows.filter(
+      (row) => row.kind === "event" || row.kind === "execution" || row.kind === "attempt" || bookkeeping(row)
+    ).map((row) => ({ label: row.label, detail: row.detail.output ?? row.detail.message ?? "" })),
+    journal: journal.map((row) => ({
+      seq: row.sequence ?? 0,
+      at: new Date(row.occurredAt ?? 0).toISOString(),
+      type: row.kind ?? "event",
+      text: JSON.stringify(row.payload) ?? "null"
+    })),
+    ...at === void 0 ? {} : { replay: { at: Math.min(at, last), last } }
+  };
+};
+//# sourceMappingURL=RunTrace.js.map