@yaklabs-ai/plugin-sdk 0.15.1 → 0.15.3

package/dist/canonical-transcript.js

@@ -0,0 +1,3842 @@
+// packages/herd-transcript/dist/context-messages.js
+var UI_ACTION_CUSTOM_TYPE = "ui_action";
+var USER_PASTED_CONTENT_CUSTOM_TYPE = "user_pasted_content";
+var ATTACHMENTS_CUSTOM_TYPE = "attachments";
+var DAEMON_SERVICE_TURN_CUSTOM_TYPE = "daemon_service_turn";
+var MID_TURN_COMPACTION_OUTCOME_CUSTOM_TYPE = "mid_turn_compaction_outcome";
+var RUN_CONTINUATION_CARRIER_CUSTOM_TYPE = "herd_run_continuation";
+var DYNAMIC_CONTEXT_CUSTOM_TYPE = "dynamic_context";
+var USER_INVOKED_CUSTOM_TYPE = "user_invoked";
+
+// packages/herd-transcript/dist/turn-messages.js
+var SUBAGENT_RESULT_CUSTOM_TYPE = "subagent_result";
+var BACKGROUND_TASK_RESULT_CUSTOM_TYPE = "background_task_result";
+
+// packages/herd-transcript/dist/run-failure-reason.js
+var RUN_FAILURE_REASONS = [
+  "auth",
+  "cancelled",
+  "content_blocked",
+  "context_overflow",
+  "invalid_request",
+  "model_disabled",
+  "model_unavailable",
+  "network",
+  "organization_unavailable",
+  "overloaded",
+  "quota_exhausted",
+  "rate_limit",
+  "runtime_interrupted",
+  "safeguard_block",
+  "seat_unpaid",
+  "server_error",
+  "sign_in_required",
+  "stream_interrupted",
+  "timeout",
+  "unknown"
+];
+
+// packages/herd-transcript/dist/run-failure.js
+import { z as z3 } from "zod";
+
+// packages/failures/dist/failure.js
+import { z } from "zod";
+
+// packages/failures/dist/json-snapshot.js
+var FAILURE_MAX_BYTES = 16 * 1024;
+var FAILURE_MAX_DEPTH = 16;
+function utf8Bytes(value) {
+  let bytes = 0;
+  for (const character of value) {
+    const point = character.codePointAt(0) ?? 0;
+    bytes += point <= 127 ? 1 : point <= 2047 ? 2 : point <= 65535 ? 3 : 4;
+  }
+  return bytes;
+}
+function snapshotJson(input) {
+  let bytes = 0;
+  const ancestors = /* @__PURE__ */ new Set();
+  function charge(text) {
+    bytes += utf8Bytes(text);
+    if (bytes > FAILURE_MAX_BYTES)
+      throw "too-large";
+  }
+  function visit2(value, depth) {
+    if (depth > FAILURE_MAX_DEPTH)
+      throw "too-deep";
+    if (value === null || typeof value === "boolean" || typeof value === "number") {
+      if (typeof value === "number" && !Number.isFinite(value))
+        throw "invalid-json";
+      charge(JSON.stringify(value));
+      return Object.is(value, -0) ? 0 : value;
+    }
+    if (typeof value === "string") {
+      if (value.length > FAILURE_MAX_BYTES)
+        throw "too-large";
+      charge(JSON.stringify(value));
+      return value;
+    }
+    if (typeof value !== "object")
+      throw "invalid-json";
+    if (ancestors.has(value))
+      throw "invalid-json";
+    const array = Array.isArray(value);
+    if (!array && ![Object.prototype, null].includes(Object.getPrototypeOf(value))) {
+      throw "invalid-json";
+    }
+    ancestors.add(value);
+    charge(array ? "[]" : "{}");
+    const keys = Reflect.ownKeys(value);
+    if (keys.length > FAILURE_MAX_BYTES)
+      throw "too-large";
+    let result;
+    if (array) {
+      const length = Object.getOwnPropertyDescriptor(value, "length")?.value;
+      if (typeof length !== "number" || !Number.isSafeInteger(length) || length < 0)
+        throw "invalid-json";
+      if (length > FAILURE_MAX_BYTES)
+        throw "too-large";
+      if (keys.some((key) => key !== "length" && (typeof key !== "string" || !/^(0|[1-9]\d*)$/.test(key) || Number(key) >= length))) {
+        throw "invalid-json";
+      }
+      const items = [];
+      for (let index = 0; index < length; index++) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (!descriptor || !("value" in descriptor))
+          throw "invalid-json";
+        if (index > 0)
+          charge(",");
+        items.push(visit2(descriptor.value, depth + 1));
+      }
+      result = Object.freeze(items);
+    } else {
+      const members = /* @__PURE__ */ Object.create(null);
+      let count2 = 0;
+      if (keys.some((key) => typeof key !== "string"))
+        throw "invalid-json";
+      for (const key of keys.sort()) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor)
+          throw "unreadable";
+        if (!descriptor.enumerable)
+          continue;
+        if (typeof key !== "string" || !("value" in descriptor))
+          throw "invalid-json";
+        if (key.length > FAILURE_MAX_BYTES)
+          throw "too-large";
+        charge((count2++ > 0 ? "," : "") + JSON.stringify(key) + ":");
+        members[key] = visit2(descriptor.value, depth + 1);
+      }
+      result = Object.freeze(members);
+    }
+    ancestors.delete(value);
+    return result;
+  }
+  try {
+    const value = visit2(input, 0);
+    return { status: "valid", value, canonical: JSON.stringify(value) };
+  } catch (error) {
+    return {
+      status: "invalid",
+      reason: error === "invalid-json" || error === "too-large" || error === "too-deep" ? error : "unreadable"
+    };
+  }
+}
+
+// packages/failures/dist/failure.js
+var failureRefSchema = z.strictObject({
+  authority: z.string().min(1).max(512),
+  id: z.string().min(1).max(512)
+});
+var FAILURE_RELATIONS = [
+  "caused-by",
+  "retry-of",
+  "recovery-of",
+  "cleanup-of"
+];
+function failureSchema(cause) {
+  const name = z.string().min(1).max(512);
+  return z.strictObject({
+    ref: failureRefSchema,
+    sourceRef: failureRefSchema,
+    domain: name,
+    code: name,
+    context: z.strictObject({
+      component: name,
+      operation: name,
+      operationRef: failureRefSchema.optional(),
+      attemptRef: failureRefSchema.optional(),
+      phase: name.optional(),
+      requestRef: failureRefSchema.optional(),
+      traceId: name.optional(),
+      spanId: name.optional()
+    }),
+    cause,
+    relations: z.array(z.strictObject({
+      kind: z.enum(FAILURE_RELATIONS),
+      failureRef: failureRefSchema
+    })).optional(),
+    diagnosticRef: failureRefSchema.optional()
+  });
+}
+function readFailure(schema, input) {
+  const before = snapshotJson(input);
+  if (before.status === "invalid")
+    return before;
+  try {
+    const parsed = schema.safeParse(before.value);
+    if (!parsed.success)
+      return { status: "invalid", reason: "schema-rejected" };
+    const after = snapshotJson(parsed.data);
+    if (after.status === "invalid")
+      return after;
+    if (before.canonical !== after.canonical)
+      return { status: "invalid", reason: "schema-changed" };
+    return {
+      status: "valid",
+      failure: after.value
+    };
+  } catch (error) {
+    void error;
+    return { status: "invalid", reason: "schema-threw" };
+  }
+}
+var jsonFailureSchema = failureSchema(z.custom());
+
+// packages/failures/dist/sequence.js
+import { z as z2 } from "zod";
+var coverageSchema = z2.strictObject({
+  scope: failureRefSchema,
+  status: z2.enum(["complete", "partial", "unknown"]),
+  knownOmittedCount: z2.number().int().nonnegative().optional()
+}).refine((value) => value.status !== "complete" || !value.knownOmittedCount);
+
+// packages/herd-transcript/dist/run-failure.js
+var RUN_FAILURE_DIAGNOSTIC_TYPE = "herd.run.failure";
+var runFailureCauseSchema = z3.strictObject({
+  reason: z3.enum(RUN_FAILURE_REASONS),
+  source: z3.enum(["assistant_message", "exception", "runtime"]),
+  authDisposition: z3.enum(["unauthorized", "forbidden"]).optional(),
+  provider: z3.string().optional(),
+  api: z3.string().optional(),
+  model: z3.string().optional(),
+  httpStatus: z3.number().int().optional(),
+  providerCode: z3.string().optional(),
+  exitCode: z3.number().int().nullable().optional(),
+  signal: z3.string().nullable().optional(),
+  observation: z3.enum(["process_exit", "next_launch"]).optional(),
+  retryAfterMs: z3.number().finite().nonnegative().optional(),
+  retryable: z3.boolean().optional(),
+  accountId: z3.string().optional(),
+  authSource: z3.enum(["oauth", "api-key"]).optional(),
+  credentialRef: z3.string().optional()
+});
+var runFailureSchema = failureSchema(runFailureCauseSchema).extend({
+  domain: z3.enum(["model", "runtime"])
+});
+var runFailureRecordSchema = z3.strictObject({
+  failure: runFailureSchema.refine((failure) => readFailure(runFailureSchema, failure).status === "valid", "invalid or oversized model failure occurrence"),
+  errorText: z3.string()
+});
+function readRunFailureOccurrence(message) {
+  const diagnostics = message.diagnostics ?? [];
+  for (let i = diagnostics.length - 1; i >= 0; i--) {
+    const diagnostic = diagnostics[i];
+    if (diagnostic?.type !== RUN_FAILURE_DIAGNOSTIC_TYPE)
+      continue;
+    const details = diagnostic.details;
+    if (typeof details !== "object" || details === null)
+      return void 0;
+    const read = readFailure(runFailureSchema, details.failure);
+    return read.status === "valid" ? read.failure : void 0;
+  }
+  return void 0;
+}
+var runRecoveryOutcomeSchema = z3.strictObject({
+  failureRef: failureRefSchema,
+  action: z3.enum(["compact", "retry", "switch_model", "switch_account"]),
+  outcome: z3.enum(["succeeded", "failed", "aborted"]),
+  resultFailureRef: failureRefSchema.optional()
+});
+
+// packages/herd-transcript/dist/events/projections.js
+import { z as z4 } from "zod";
+var ManagedQueuePresentationAnchor = z4.strictObject({
+  sentAt: z4.number().finite(),
+  turnId: z4.string().min(1).optional(),
+  itemId: z4.string().min(1),
+  contentOffset: z4.number().int().nonnegative().optional()
+});
+var ManagedQueueAttachmentRef = z4.strictObject({
+  uri: z4.string().min(1),
+  name: z4.string().min(1),
+  mimeType: z4.string().min(1)
+});
+var ManagedQueueContextPart = z4.discriminatedUnion("kind", [
+  z4.strictObject({
+    kind: z4.literal("tab_context"),
+    body: z4.string(),
+    surface: z4.string()
+  }),
+  z4.strictObject({
+    kind: z4.literal("ui_action"),
+    action: z4.string(),
+    toolCallId: z4.string(),
+    payload: z4.string()
+  }),
+  z4.strictObject({
+    kind: z4.literal("composer_references"),
+    mentions: z4.array(z4.strictObject({
+      ref: z4.string(),
+      serviceId: z4.string(),
+      entityType: z4.string()
+    })),
+    invocations: z4.array(z4.strictObject({ id: z4.string(), serviceId: z4.string() }))
+  }),
+  z4.strictObject({
+    kind: z4.literal("user_pasted_content"),
+    items: z4.array(z4.union([
+      z4.strictObject({
+        id: z4.string(),
+        lineCount: z4.number().int().positive(),
+        text: z4.string(),
+        /** These exact bytes also appear in the message text, verbatim. */
+        inline: z4.literal(true).optional(),
+        attachment: z4.never().optional()
+      }),
+      z4.strictObject({
+        id: z4.string(),
+        lineCount: z4.number().int().positive(),
+        text: z4.never().optional(),
+        inline: z4.never().optional(),
+        attachment: z4.strictObject({
+          name: z4.string(),
+          uri: z4.string().optional()
+        })
+      })
+    ]))
+  })
+]);
+var ContextAttribution = z4.object({
+  source: z4.string().min(1),
+  path: z4.string().optional(),
+  scope: z4.string().optional(),
+  origin: z4.string().optional(),
+  baseDir: z4.string().optional(),
+  id: z4.string().optional(),
+  sourceId: z4.string().optional(),
+  label: z4.string().optional()
+}).strict();
+var ContextWindowBucketCategory = z4.enum([
+  "system_prompt:base",
+  "system_prompt:append",
+  "system_prompt:tool_section",
+  "system_prompt:connectable_tools",
+  "system_prompt:guidelines",
+  "system_prompt:addressable_resources",
+  "system_prompt:plugins",
+  "system_prompt:documentation",
+  "system_prompt:context_file",
+  "system_prompt:skills",
+  "system_prompt:connected_accounts",
+  "system_prompt:metadata",
+  "system_prompt:layout",
+  "system_prompt:headless_operation",
+  "system_prompt:agent_configuration",
+  "tool_definitions",
+  "user_message",
+  "assistant_message",
+  "tool_result",
+  "context_message",
+  "context_message:dynamic_context",
+  "context_message:subagent_result",
+  "compaction_summary"
+]);
+var HerdContextWindowSnapshot = z4.strictObject({
+  revision: z4.number().int().positive(),
+  /**
+   * The ACTUAL context usage (provider-anchored; see `ContextUsage` in ../context-window.ts).
+   * The buckets/estimatedTotalTokens below are estimated-composition metadata
+   * and must never drive a headline percentage or system decision.
+   */
+  usage: z4.strictObject({
+    tokens: z4.number().int().nonnegative(),
+    basis: z4.enum(["provider", "estimate"]),
+    anchorTokens: z4.number().int().nonnegative(),
+    tailTokens: z4.number().int().nonnegative()
+  }),
+  buckets: z4.array(z4.strictObject({
+    label: z4.string(),
+    category: ContextWindowBucketCategory,
+    estimatedTokens: z4.number().int().nonnegative(),
+    attributions: z4.array(ContextAttribution),
+    resourceIdentity: z4.strictObject({
+      id: z4.string().min(1),
+      version: z4.string().min(1),
+      variantId: z4.string().min(1).optional()
+    }).optional()
+  })),
+  estimatedTotalTokens: z4.number().int().nonnegative(),
+  model: z4.strictObject({
+    provider: z4.string().min(1),
+    id: z4.string().min(1),
+    contextWindow: z4.number().int().positive().optional()
+  })
+});
+var HERD_MESSAGE_DELTA_CONTENT_INDEX_MAX = 1024;
+var boundedDeltaPlacement = z4.json().refine((delta) => {
+  if (typeof delta !== "object" || delta === null || Array.isArray(delta)) {
+    return true;
+  }
+  const contentIndex = delta["contentIndex"];
+  return contentIndex === void 0 || typeof contentIndex === "number" && Number.isInteger(contentIndex) && contentIndex >= 0 && contentIndex <= HERD_MESSAGE_DELTA_CONTENT_INDEX_MAX;
+}, { message: "delta contentIndex out of bounds" });
+var HerdSessionProjection = z4.discriminatedUnion("type", [
+  z4.strictObject({
+    type: z4.literal("herd.message.delta"),
+    runId: z4.string().min(1).optional(),
+    messageId: z4.string().min(1).optional(),
+    timestamp: z4.iso.datetime(),
+    delta: boundedDeltaPlacement
+  }),
+  z4.strictObject({
+    type: z4.literal("herd.custom.entry.appended"),
+    customType: z4.string().min(1),
+    data: z4.json()
+  }),
+  z4.strictObject({
+    type: z4.literal("herd.context.window.updated"),
+    snapshot: HerdContextWindowSnapshot,
+    /**
+     * Why this snapshot was taken. `provider_request` — emitted synchronously
+     * from the model-boundary context hook (every LLM request boundary);
+     * `refresh` — emitted on all other paths (post-compaction rebuild, model
+     * change, post-run settlement). Absent on legacy stored projections.
+     */
+    cause: z4.enum(["provider_request", "refresh"]).optional(),
+    /**
+     * Counters from the model-boundary supersede pass, present only on a `provider_request`
+     * projection whose pass actually elided something. Absent means the pass was a no-op for
+     * that request, never "unknown". `reclaimedTokens` is CARRIED (re-counted on every later
+     * request the elision keeps content off the wire), and `firstRequestAfterBoundary` is the cold/warm
+     * discriminator any pricing MUST split on — see `ContextElisionStats` in herd's
+     * context-projection module for the full read rules.
+     */
+    elision: z4.strictObject({
+      supersededResults: z4.number().int().positive(),
+      reclaimedTokens: z4.number().int().nonnegative(),
+      firstRequestAfterBoundary: z4.boolean(),
+      coldBoundaryMs: z4.number().int().nonnegative()
+    }).optional(),
+    /** Identified subagent task ids included in this request; `[]` means none, absent means legacy. */
+    requestIncludedSubagentTaskIds: z4.array(z4.string().min(1).max(1024)).max(4096).optional()
+  }),
+  z4.strictObject({
+    type: z4.literal("herd.managed.human.queue.updated"),
+    snapshot: z4.strictObject({
+      revision: z4.number().int().nonnegative(),
+      items: z4.array(z4.strictObject({
+        id: z4.string().min(1),
+        clientIntentId: z4.string().min(1).optional(),
+        presentationAnchor: ManagedQueuePresentationAnchor.optional(),
+        attachments: z4.array(ManagedQueueAttachmentRef).optional(),
+        context: z4.array(ManagedQueueContextPart).optional(),
+        resendError: z4.string().optional(),
+        text: z4.string(),
+        channel: z4.enum(["follow_up", "steer"]),
+        status: z4.enum(["queued", "editing"])
+      }))
+    })
+  })
+]);
+var HerdSessionDiagnostic = z4.strictObject({
+  type: z4.literal("herd.kernel.event.redacted"),
+  originalType: z4.string().min(1)
+});
+
+// packages/herd-transcript/dist/final-output.js
+var RESERVED_FINAL_OUTPUT_TOOL_NAME = "submit_final";
+function finalOutputCaptureFromDetails(toolCallId, details) {
+  if (details === null || typeof details !== "object")
+    return void 0;
+  const value = details;
+  return value.kind === "final_output" && "result" in value ? {
+    toolCallId,
+    ...typeof value.terminatesRun === "boolean" ? { terminatesRun: value.terminatesRun } : {},
+    // Legacy transcripts carry the duplicated reply prose; new entries do
+    // not. Read it only when it is actually a string — durable data.
+    ...typeof value.message === "string" ? { message: value.message } : {},
+    result: value.result,
+    // Re-checked on the way out of durable storage, not trusted from it: a
+    // replayed log entry is data, and a non-string here would otherwise
+    // reach the rename path untyped.
+    ...typeof value.sessionTitle === "string" ? { sessionTitle: value.sessionTitle } : {}
+  } : void 0;
+}
+var FINAL_OUTPUT_REPAIR_CUSTOM_TYPE = "herd.final_output_repair";
+
+// packages/herd-transcript/dist/interactive/embedded-agent-continuation.js
+var DETACHED_WORK_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+function isSettledDetachedWork(details) {
+  const status = details["status"];
+  return typeof status === "string" && DETACHED_WORK_STATUSES.has(status);
+}
+function isSubagentResultDetails(details) {
+  const record = asRecord(details);
+  if (record === void 0 || !isSettledDetachedWork(record))
+    return false;
+  const provenance = asRecord(record["provenance"]);
+  const attribution = asRecord(record["attribution"]);
+  return provenance?.["source"] === "subagent" && isNonEmptyString(provenance["sourceId"]) || attribution?.["kind"] === "subagent" && isNonEmptyString(attribution["childSessionId"]);
+}
+function isBackgroundTaskResultDetails(details) {
+  const record = asRecord(details);
+  if (record === void 0 || !isSettledDetachedWork(record))
+    return false;
+  const provenance = asRecord(record["provenance"]);
+  return provenance?.["source"] === "background_task" && isNonEmptyString(provenance["sourceId"]) && (record["taskKind"] === "bash" || record["taskKind"] === "agent") && typeof record["truncated"] === "boolean";
+}
+function isDaemonWakeDetails(details) {
+  const record = asRecord(details);
+  const provenance = asRecord(record?.["provenance"]);
+  if (provenance?.["source"] !== "daemon")
+    return false;
+  const service = record?.["service"];
+  return service === "wake" && provenance["sourceId"] === "wake" || service === "subagent_wake" && provenance["sourceId"] === "subagent_wake";
+}
+function isEmbeddedAgentResultMessage(item) {
+  if (item.role !== "custom" || item.status !== "complete")
+    return false;
+  if (item.customType === SUBAGENT_RESULT_CUSTOM_TYPE)
+    return isSubagentResultDetails(item.details);
+  if (item.customType === BACKGROUND_TASK_RESULT_CUSTOM_TYPE)
+    return isBackgroundTaskResultDetails(item.details);
+  return false;
+}
+function isRequiredFinalOutputRepairMessage(item) {
+  return item.role === "custom" && item.status === "complete" && item.customType === FINAL_OUTPUT_REPAIR_CUSTOM_TYPE;
+}
+function isDaemonWakeMessage(item) {
+  return item.role === "custom" && item.status === "complete" && item.customType === DAEMON_SERVICE_TURN_CUSTOM_TYPE && isDaemonWakeDetails(item.details);
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" ? value : void 0;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+
+// packages/herd-transcript/dist/message-roles.js
+var TOOL_RESULT_ROLE = "toolResult";
+var KERNEL_MESSAGE_ROLES = {
+  user: true,
+  assistant: true,
+  toolResult: true,
+  // pi-ai 0.86+: the system prompt travels as a transcript `system` message
+  // (TranscriptContext). It is a model-boundary carrier, not chat content.
+  system: true
+};
+function isKernelMessageRole(role) {
+  return Object.hasOwn(KERNEL_MESSAGE_ROLES, role);
+}
+
+// packages/herd-transcript/dist/run-failure-classifier.js
+var MAX_FAILURE_TEXT_CHARS = 2e3;
+function boundedFailureText(text) {
+  const normalized = text?.trim() || "Run failed.";
+  return normalized.length > MAX_FAILURE_TEXT_CHARS ? `${normalized.slice(0, MAX_FAILURE_TEXT_CHARS)}\u2026` : normalized;
+}
+var HTML_DOCUMENT_PREFIX = /^(?:<!doctype\s+html|<html[\s>]|<head[\s>]|<body[\s>])/;
+var MAX_HTML_EXTRACT_CHARS = 16e3;
+var OPAQUE_HTML_FAILURE_TEXT = "The model provider returned an HTML error page with no readable message.";
+function looksLikeHtml(text) {
+  return HTML_DOCUMENT_PREFIX.test(text.trimStart().slice(0, 128).toLowerCase());
+}
+function readableFailureText(text) {
+  const normalized = text?.trim() || "Run failed.";
+  if (!looksLikeHtml(normalized))
+    return boundedFailureText(normalized);
+  const extracted = htmlToReadableText(normalized);
+  return boundedFailureText(extracted === "" ? OPAQUE_HTML_FAILURE_TEXT : extracted);
+}
+function htmlToReadableText(html) {
+  const capped = html.slice(0, MAX_HTML_EXTRACT_CHARS);
+  const title = plainText(/<title\b[^>]*>([\s\S]*?)<\/title>/i.exec(capped)?.[1] ?? "");
+  const body = plainText(capped);
+  if (title === "" || body.includes(title))
+    return body === "" ? title : body;
+  return body === "" ? title : `${title} ${body}`;
+}
+function plainText(html) {
+  const withoutComments = html.includes("-->") ? html.replace(/<!--[\s\S]*?-->/g, " ") : html;
+  const text = withoutComments.replace(/<(script|style|template|svg|head)\b[^>]*>[\s\S]*?<\/\1>/gi, " ").replace(/<[^>]+>/g, " ").replace(/<[^>]*$/, " ");
+  return collapseWhitespace(decodeCommonHtmlEntities(text));
+}
+function decodeCommonHtmlEntities(text) {
+  return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#0?39;/g, "'").replace(/&nbsp;/g, " ").replace(/&amp;/g, "&");
+}
+function collapseWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+
+// packages/herd-transcript/dist/interactive/presentation-anchor.js
+var PRESENTATION_ANCHOR_KEYS = /* @__PURE__ */ new Set([
+  "sentAt",
+  "turnId",
+  "itemId",
+  "contentOffset"
+]);
+function parsePresentationAnchor(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return void 0;
+  }
+  const record = value;
+  if (Object.keys(record).some((key) => !PRESENTATION_ANCHOR_KEYS.has(key))) {
+    return void 0;
+  }
+  const { sentAt, turnId, itemId, contentOffset } = record;
+  if (typeof sentAt !== "number" || !Number.isFinite(sentAt)) {
+    return void 0;
+  }
+  if (typeof itemId !== "string" || itemId.length === 0) {
+    return void 0;
+  }
+  if (turnId !== void 0 && (typeof turnId !== "string" || turnId.length === 0)) {
+    return void 0;
+  }
+  if (contentOffset !== void 0 && (typeof contentOffset !== "number" || !Number.isInteger(contentOffset) || contentOffset < 0)) {
+    return void 0;
+  }
+  return {
+    sentAt,
+    itemId,
+    ...Object.hasOwn(record, "turnId") ? { turnId } : {},
+    ...Object.hasOwn(record, "contentOffset") ? { contentOffset } : {}
+  };
+}
+
+// packages/herd-transcript/dist/tool-call-failure.js
+import { z as z5 } from "zod";
+
+// packages/herd-transcript/dist/is-object.js
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// packages/herd-transcript/dist/tool-call-failure.js
+var TOOL_CALL_FAILURE_DETAILS_KEY = "toolCallFailure";
+var TOOL_CALL_FAILURE_DOMAIN = "tool-call";
+var TOOL_CALL_FAILURE_CATEGORIES = [
+  "invalid-input",
+  "not-connected",
+  "unsupported-operation",
+  "not-found",
+  "provider",
+  "permission",
+  "timeout",
+  "unavailable",
+  "cancelled",
+  "unknown"
+];
+var TOOL_CALL_FAILURE_ACTIONS = [
+  "correct-input",
+  "connect",
+  "retry",
+  "none",
+  "unknown"
+];
+var TOOL_CALL_FAILURE_CODES = [
+  "tool.invalid_input",
+  "tool.blocked",
+  "tool.cancelled",
+  "tool.timeout",
+  "tool.not_found",
+  "tool.unavailable",
+  "tool.execution_failed",
+  "provider.http",
+  "provider.api",
+  "provider.transport",
+  "uri.not_found",
+  "uri.unsupported_operation",
+  "uri.not_connected",
+  "uri.auth_unavailable",
+  "permission.denied",
+  "edit.empty_edits",
+  "edit.text_not_found",
+  "edit.text_not_unique",
+  "edit.empty_old_text",
+  "edit.overlapping_edits",
+  "edit.no_change"
+];
+var count = z5.number().int().nonnegative();
+var toolCallFailureDetailsSchema = z5.strictObject({
+  moduleId: z5.string().optional(),
+  /**
+   * [#5042] The registration that owns the FAILING TOOL, host-stamped from the
+   * session's own tool source index — `herd.core` for a kernel tool,
+   * `kay.task-introspection` for a daemon app-extension's, a plugin's id for a
+   * plugin's, and the bare layer sentinel (`builtin`, `host`, `extension`) when
+   * a registration named no owner.
+   *
+   * Distinct from {@link moduleId}, which names a URI MODULE and is stamped
+   * only by a URI verb dispatch (#4954). Every failure has an owning tool; only
+   * a URI dispatch has a module. Read together they answer "who failed" for
+   * every tool call rather than only the URI ones — the fall-through #4954 left
+   * open, where a `task`-kind tool throwing a plain `Error` reached the
+   * classifier's terminal branch with nothing to attribute it to.
+   *
+   * Never self-reported: like the dispatch identity, this comes from the host's
+   * registry, not from the error, so a plugin cannot claim one of ours.
+   */
+  toolOwnerId: z5.string().optional(),
+  operation: z5.string().optional(),
+  uri: z5.string().optional(),
+  path: z5.string().optional(),
+  validationField: z5.string().optional(),
+  errorName: z5.string().optional(),
+  errorCode: z5.string().optional(),
+  providerCode: z5.string().optional(),
+  status: z5.number().int().min(100).max(599).optional(),
+  editIndex: count.optional(),
+  occurrences: count.optional(),
+  /** Provider-directed delay before retrying, in milliseconds. */
+  retryAfterMs: count.optional()
+});
+var toolCallFailureCauseSchema = z5.strictObject({
+  category: z5.enum(TOOL_CALL_FAILURE_CATEGORIES),
+  retryable: z5.boolean(),
+  action: z5.enum(TOOL_CALL_FAILURE_ACTIONS),
+  details: toolCallFailureDetailsSchema.optional()
+});
+var toolCallFailureOccurrenceSchema = failureSchema(toolCallFailureCauseSchema).extend({
+  domain: z5.literal(TOOL_CALL_FAILURE_DOMAIN),
+  code: z5.enum(TOOL_CALL_FAILURE_CODES)
+});
+var toolCallFailureSchema = toolCallFailureCauseSchema.extend({
+  code: toolCallFailureOccurrenceSchema.shape.code
+});
+function readToolCallFailure(details) {
+  if (!isObject(details))
+    return void 0;
+  const read = readFailure(toolCallFailureOccurrenceSchema, details[TOOL_CALL_FAILURE_DETAILS_KEY]);
+  return read.status === "valid" ? read.failure : void 0;
+}
+
+// packages/herd-transcript/dist/interactive/reducer.js
+var UNKNOWN_ACTIVITY_CUSTOM_TYPE = "herd.unknown_activity";
+var TOOL_ACTIVITY_KINDS = /* @__PURE__ */ new Set([
+  "inspect-workspace",
+  "run-command",
+  "edit-files",
+  "view-image",
+  "wait"
+]);
+function createInteractiveModeState(options = {}) {
+  return {
+    items: normalizeToolIdentities(options.items ?? []),
+    ...stringField("sessionName", options.sessionName),
+    ...stringField("streamingAssistantId", options.streamingAssistantId),
+    pendingToolsByCallId: options.pendingToolsByCallId ?? {},
+    queue: options.queue ?? [],
+    ...options.queueRevision !== void 0 ? { queueRevision: options.queueRevision } : {},
+    run: options.run ?? { status: "idle" },
+    ...options.terminalFailure === void 0 ? {} : { terminalFailure: options.terminalFailure },
+    ...options.completedRunBoundaryAnchors === void 0 ? {} : { completedRunBoundaryAnchors: options.completedRunBoundaryAnchors },
+    backgroundTasksById: options.backgroundTasksById ?? {},
+    nextItemIndex: options.nextItemIndex ?? 1,
+    customEntries: options.customEntries ?? {},
+    ...options.activity !== void 0 ? { activity: options.activity } : {}
+  };
+}
+function withActivity(state, activity) {
+  return { ...state, activity };
+}
+function clearActivity(state) {
+  if (state.activity === void 0)
+    return state;
+  const { activity: _omitted, ...rest } = state;
+  void _omitted;
+  return rest;
+}
+function recordCompletedRunBoundary(state) {
+  const item = state.items.at(-1);
+  if (item === void 0)
+    return state;
+  const anchor = { type: item.type, id: item.id };
+  const prior = state.completedRunBoundaryAnchors ?? [];
+  const previous = prior.at(-1);
+  if (previous?.type === anchor.type && previous.id === anchor.id)
+    return state;
+  return {
+    ...state,
+    completedRunBoundaryAnchors: [...prior, anchor]
+  };
+}
+var COMPACTION_MARKER_CUSTOM_TYPE = "compaction";
+function reduceSessionCompact(state, event, replay) {
+  const cleared = state.activity?.kind === "compaction" ? clearActivity(state) : state;
+  const entry = asRecord2(asRecord2(event)?.["compactionEntry"]);
+  const at = getString(entry, "timestamp") ?? getTimestamp(event);
+  const id = getString(entry, "id") ?? allocateItemId(cleared, "compaction-marker");
+  const summary = getString(entry, "summary");
+  const details = {
+    ...at === void 0 ? {} : { at },
+    ...summary === void 0 || summary.length === 0 ? {} : { summary }
+  };
+  const item = {
+    id,
+    type: "message",
+    role: "custom",
+    customType: COMPACTION_MARKER_CUSTOM_TYPE,
+    status: "complete",
+    text: "",
+    parts: [],
+    details,
+    ...at !== void 0 ? { startedAt: at, completedAt: at } : {}
+  };
+  return upsertMessageItem(cleared, item, replay);
+}
+function normalizeToolIdentities(items) {
+  let changed = false;
+  let activeWaveId;
+  const generationsByCorrelationId = /* @__PURE__ */ new Map();
+  const normalized = items.map((item) => {
+    if (item.type !== "tool") {
+      activeWaveId = void 0;
+      return item;
+    }
+    const recordedGeneration = Number.isInteger(item.attemptGeneration) && item.attemptGeneration > 0 ? item.attemptGeneration : void 0;
+    const generation = recordedGeneration ?? (generationsByCorrelationId.get(item.toolCallId) ?? 0) + 1;
+    generationsByCorrelationId.set(item.toolCallId, Math.max(generationsByCorrelationId.get(item.toolCallId) ?? 0, generation));
+    const attemptId = item.attemptId ?? `tool-attempt:${encodeURIComponent(item.id)}`;
+    const waveId = item.waveId ?? activeWaveId ?? canonicalWaveId(item.responseId ?? item.sourceMessageId ?? `legacy:${item.id}`);
+    activeWaveId = waveId;
+    if (item.attemptId === attemptId && item.waveId === waveId && item.attemptGeneration === generation) {
+      return item;
+    }
+    changed = true;
+    return { ...item, attemptId, waveId, attemptGeneration: generation };
+  });
+  return changed ? normalized : items;
+}
+function reduceInteractiveModeEventsForReplay(events) {
+  let state = createInteractiveModeState();
+  const replay = createReplayIndex(state);
+  for (const event of events) {
+    state = event.type === "host_run_status" ? reduceHostRun(state, event.run, replay) : reduceInteractiveModeEventInternal(state, event, replay);
+  }
+  return state;
+}
+function reduceHostRun(state, next, replay) {
+  switch (next.status) {
+    case "idle":
+      return clearTransientState(state, { status: "idle" }, { status: "interrupted" }, replay);
+    case "running": {
+      const previous = state.run;
+      if (previous.status === "running" && previous.resuming !== true && previous.runId === next.runId) {
+        if (previous.retry === void 0)
+          return state;
+        const { retry: _retry, ...run } = previous;
+        void _retry;
+        return { ...state, run };
+      }
+      return withoutTerminalFailure({
+        ...state,
+        run: { status: "running", ...stringField("runId", next.runId) }
+      });
+    }
+    case "retry_waiting":
+      return {
+        ...state,
+        run: {
+          ...state.run,
+          status: "running",
+          ...stringField("runId", next.runId),
+          retry: {
+            ...stringField("waitId", next.retry.waitId),
+            attempt: next.retry.attempt,
+            maxAttempts: next.retry.maxAttempts,
+            ...next.retry.reason === void 0 ? {} : { reason: next.retry.reason }
+          }
+        }
+      };
+    case "resuming":
+      return clearTransientState(state, {
+        status: "running",
+        ...stringField("runId", next.runId),
+        resuming: true
+      }, { status: "interrupted" }, replay);
+    case "settled":
+      return reduceSettledRun(state, next, replay);
+  }
+}
+function reduceSettledRun(state, next, replay) {
+  switch (next.outcome) {
+    case "completed":
+      return withoutTerminalFailure(recordCompletedRunBoundary(clearTransientState(state, { status: "settled" }, { status: "interrupted" }, replay)));
+    case "interrupted":
+    case "cancelled":
+      return withoutTerminalFailure(clearTransientState(markAbortedAssistant(state, replay), { status: "aborted" }, { status: "interrupted" }, replay));
+    case "failed": {
+      const errorText = next.failure?.errorText;
+      const selected = runFailureRecordSchema.safeParse({
+        failure: next.failure?.failure,
+        errorText
+      });
+      const rest = withoutTerminalFailure(state);
+      return clearTransientState(selected.success ? { ...rest, terminalFailure: selected.data } : rest, { status: "error", ...stringField("errorText", errorText) }, { status: "error", ...stringField("errorText", errorText) }, replay);
+    }
+  }
+}
+function withoutTerminalFailure(state) {
+  if (state.terminalFailure === void 0)
+    return state;
+  const { terminalFailure: _terminalFailure, ...rest } = state;
+  void _terminalFailure;
+  return rest;
+}
+function reduceInteractiveModeEventInternal(state, event, replay) {
+  switch (event.type) {
+    case "session_info_updated":
+      return withSessionName(state, getString(event, "name"));
+    case "agent_start": {
+      const { terminalFailure: _terminalFailure, ...active } = state;
+      const base = resetReplayIndex(replay, {
+        ...withoutStreamingAssistant(terminalizeOpenItems(active, { status: "interrupted" }, replay)),
+        pendingToolsByCallId: {},
+        run: { status: "running" }
+      });
+      return base.activity?.phase === "failed" ? clearActivity(base) : base;
+    }
+    case "turn_start":
+      return {
+        ...state,
+        run: { status: "running" }
+      };
+    case "queue_update":
+      return state.queueRevision === void 0 ? { ...state, queue: extractQueuedMessages(event) } : state;
+    case "managed_human_queue_update":
+      return reduceManagedHumanQueueUpdate(state, event);
+    case "message_start":
+    case "message_update":
+    case "message_end": {
+      switch (messageRoleDisposition(getRawMessageRole(event))) {
+        case "fold_tool_result":
+          return reduceToolResultMessage(state, event, replay);
+        case "drop":
+          return state;
+        case "project_unknown": {
+          const normalized = normalizeUnknownMessageEvent(event);
+          return event.type === "message_start" ? reduceMessageStart(state, normalized, replay) : event.type === "message_update" ? reduceMessageUpdate(state, normalized, replay) : reduceMessageEnd(state, normalized, replay);
+        }
+        case "project":
+          return event.type === "message_start" ? reduceMessageStart(state, event, replay) : event.type === "message_update" ? reduceMessageUpdate(state, event, replay) : reduceMessageEnd(state, event, replay);
+      }
+    }
+    case "tool_execution_start":
+      return reduceToolExecution(state, event, "running", replay);
+    case "tool_execution_update":
+      return reduceToolExecution(state, event, "running", replay);
+    case "tool_execution_end":
+      return reduceToolCompletion(state, normalizeToolExecutionCompletion(event), replay);
+    case "background_task_started":
+      return reduceBackgroundTask(state, event, "running", replay);
+    case "background_task_progress":
+      return reduceBackgroundTask(state, event, "running", replay);
+    case "background_task_completed":
+      return reduceBackgroundTask(state, event, "complete", replay);
+    case "background_task_failed":
+      return reduceBackgroundTask(state, event, "failed", replay);
+    case "background_task_cancelled":
+      return reduceBackgroundTask(state, event, "cancelled", replay);
+    case "abort":
+      return clearTransientState(markAbortedAssistant(state, replay), { status: "aborted" }, { status: "interrupted" }, replay);
+    case "settled":
+      return recordCompletedRunBoundary(clearTransientState(state, { status: "settled" }, { status: "interrupted" }, replay));
+    case "turn_end":
+      return clearTransientState(state, state.run, { status: "interrupted" }, replay);
+    case "agent_end":
+      return clearTransientState(state, { status: "idle" }, { status: "interrupted" }, replay);
+    case "compaction_triggered":
+      return withActivity(state, { kind: "compaction", phase: "running" });
+    case "session_compact":
+      return reduceSessionCompact(state, event, replay);
+    case "compaction_failed":
+      return withActivity(state, { kind: "compaction", phase: "failed" });
+    case "custom_entry":
+      return reduceCustomEntry(state, event);
+    case "run_failed": {
+      if (!drivesTheReducedRun(event))
+        return state;
+      const selected = runFailureRecordSchema.safeParse({
+        failure: asRecord2(event)?.["failure"],
+        errorText: getString(event, "errorText")
+      });
+      const { terminalFailure: _oldFailure, ...rest } = state;
+      return clearTransientState({
+        ...rest,
+        ...selected.success ? { terminalFailure: selected.data } : {}
+      }, {
+        status: "error",
+        ...stringField("errorText", getString(event, "errorText"))
+      }, {
+        status: "error",
+        ...stringField("errorText", getString(event, "errorText"))
+      }, replay);
+    }
+    case "run_retrying": {
+      if (!drivesTheReducedRun(event))
+        return state;
+      const retryReason = getString(event, "reason");
+      return clearTransientState(state, {
+        status: "running",
+        retry: {
+          attempt: getNumber(event, "attempt") ?? 0,
+          maxAttempts: getNumber(event, "maxAttempts") ?? 0,
+          ...retryReason !== void 0 ? { reason: retryReason } : {}
+        }
+      }, {
+        status: "error",
+        ...stringField("errorText", getString(event, "errorText"))
+      }, replay);
+    }
+    case "run_recovered": {
+      if (!drivesTheReducedRun(event))
+        return state;
+      const { retry: _retry, ...run } = state.run;
+      void _retry;
+      return { ...state, run };
+    }
+    default:
+      return state;
+  }
+}
+function reduceMessageStart(state, event, replay) {
+  const role = getMessageRole(event);
+  const itemId = getMessageId(event) ?? allocateItemId(state, "message");
+  const extractedParts = extractContentParts(event);
+  const parts = role === "assistant" ? sanitizeAssistantContentParts(extractedParts) : extractedParts;
+  const text = parts.length > 0 ? textFromContentParts(parts) : role === "assistant" ? sanitizeAssistantText(extractText(event)) : extractText(event);
+  const display = role === "custom" ? getMessageDisplay(event) : void 0;
+  const item = {
+    id: itemId,
+    ...stringField("entryId", getEntryId(event)),
+    type: "message",
+    role,
+    ...role === "custom" ? stringField("customType", getCustomType(event)) : {},
+    ...role === "custom" && getMessageDetails(event) !== void 0 ? { details: getMessageDetails(event) } : {},
+    ...display === void 0 ? {} : { display },
+    ...role === "user" ? stringField("deliveredVia", getDeliveredVia(event)) : {},
+    ...role === "user" ? presentationAnchorField(getPresentationAnchor(event)) : {},
+    status: role === "assistant" ? "streaming" : "complete",
+    text,
+    parts,
+    ...stringField("startedAt", getTimestamp(event)),
+    ...role === "assistant" && text.trim().length > 0 ? stringField("firstTextAt", getTimestamp(event)) : {},
+    // A message that starts already-terminal (user/custom, or a replayed
+    // entry) has no later end event to stamp its completion.
+    ...role === "assistant" ? {} : stringField("completedAt", getTimestamp(event)),
+    ...messageMetadata(event, role === "assistant" ? "provisional" : void 0)
+  };
+  const nextState = upsertMessageItem(state, item, replay);
+  const withTools = upsertToolCalls(nextState, extractToolCalls(event), "declared", messageAttemptContext(item), replay);
+  return {
+    ...withTools,
+    ...role === "assistant" ? { streamingAssistantId: itemId } : {}
+  };
+}
+function reduceMessageUpdate(state, event, replay) {
+  const messageId = getMessageId(event) ?? state.streamingAssistantId;
+  const current = messageId !== void 0 ? findMessageItem(state, messageId, replay) : void 0;
+  const updated = current === void 0 ? void 0 : mergeMessageUpdate(current, event);
+  const baseState = updated !== void 0 ? replaceMessageItem(state, updated, replay) : reduceMessageStart(state, {
+    ...event,
+    role: "assistant"
+  }, replay);
+  const message = updated ?? (messageId !== void 0 ? findMessageItem(baseState, messageId, replay) : void 0);
+  return upsertToolCalls(baseState, message === void 0 ? extractToolCalls(event) : extractToolCalls({ content: message.parts }), "declared", message === void 0 ? void 0 : messageAttemptContext(message), replay);
+}
+function mergeMessageUpdate(item, event) {
+  const record = asRecord2(event);
+  if (record?.["delta"] === void 0 || record["message"] !== void 0 || record["entry"] !== void 0 || record["text"] !== void 0 || record["content"] !== void 0 || record["partial"] !== void 0 || record["assistantMessageEvent"] !== void 0) {
+    return mergeMessageContent(item, event, "streaming");
+  }
+  return mergeMessageDelta(item, event);
+}
+function reduceMessageEnd(state, event, replay) {
+  const messageId = getMessageId(event) ?? state.streamingAssistantId;
+  const current = messageId !== void 0 ? findMessageItem(state, messageId, replay) : void 0;
+  const withMessage = current !== void 0 ? upsertMessageItem(state, mergeMessageContent(current, event, hasMessageError(event) ? "error" : "complete"), replay) : state;
+  const withTools = upsertToolCalls(withMessage, extractToolCalls(event), "arguments_complete", current === void 0 ? void 0 : messageAttemptContext(current), replay);
+  const finalized = messageId === void 0 || withTools.streamingAssistantId !== messageId ? withTools : withoutStreamingAssistant(withTools);
+  const finishReason = finishReasonFor(event, extractContentParts(event));
+  if (finishReason !== "interrupted" && finishReason !== "cancelled" && finishReason !== "error") {
+    return finalized;
+  }
+  const errorText = finishReason === "error" ? getErrorText(asRecord2(event)) : void 0;
+  if (messageId === void 0)
+    return finalized;
+  return terminalizeMessageItems(finalized, messageId, {
+    status: finishReason === "error" ? "error" : "interrupted",
+    ...errorText === void 0 ? {} : { errorText }
+  }, replay);
+}
+function mergeMessageContent(item, event, status) {
+  const extractedParts = extractContentParts(event);
+  const parts = item.role === "assistant" ? sanitizeAssistantContentParts(extractedParts) : extractedParts;
+  const text = parts.length > 0 ? textFromContentParts(parts) : item.role === "assistant" ? sanitizeAssistantText(extractText(event)) : extractText(event);
+  const effectiveParts = parts.length > 0 ? parts : item.parts;
+  const mergedText = text !== "" ? text : item.text;
+  return {
+    ...item,
+    ...stringField("entryId", getEntryId(event)),
+    ...item.role === "assistant" ? stringField("forkEntryId", getEntryId(event)) : {},
+    status,
+    text: mergedText,
+    parts: effectiveParts,
+    ...item.firstTextAt === void 0 && mergedText.trim().length > 0 ? stringField("firstTextAt", getTimestamp(event)) : {},
+    // The terminal merge (message_end) stamps completion; `startedAt` was
+    // stamped at message_start and is never overwritten by later events.
+    ...status === "streaming" || item.completedAt !== void 0 ? {} : stringField("completedAt", getTimestamp(event)),
+    ...messageMetadata(event, textPhaseFor(event, effectiveParts), effectiveParts)
+  };
+}
+function mergeMessageDelta(item, event) {
+  const delta = asRecord2(getPath(event, ["delta"]));
+  const deltaType = getString(delta, "type");
+  if (delta === void 0 || deltaType === void 0) {
+    return { ...item, status: "streaming" };
+  }
+  const declared = getNumber(delta, "contentIndex");
+  if (declared !== void 0 && (!Number.isInteger(declared) || declared < 0 || declared > HERD_MESSAGE_DELTA_CONTENT_INDEX_MAX)) {
+    return item;
+  }
+  const parts = [...item.parts];
+  const contentIndex = resolveDeltaContentIndex(parts, delta, deltaType);
+  const updatedPart = applyMessageDeltaPart(parts[contentIndex], delta, deltaType, contentIndex);
+  if (updatedPart !== void 0)
+    parts[contentIndex] = updatedPart;
+  const text = textFromContentParts(parts);
+  return {
+    ...item,
+    status: "streaming",
+    text,
+    parts,
+    ...item.firstTextAt === void 0 && text.trim().length > 0 ? stringField("firstTextAt", getTimestamp(event)) : {},
+    ...messageMetadata(event, textPhaseFor(event, parts), parts)
+  };
+}
+function resolveDeltaContentIndex(parts, delta, deltaType) {
+  const declared = getNumber(delta, "contentIndex");
+  if (declared !== void 0 && Number.isInteger(declared) && declared >= 0) {
+    return Math.min(declared, parts.length);
+  }
+  const expectedType = deltaType.startsWith("text_") ? "text" : deltaType.startsWith("thinking_") ? "thinking" : deltaType.startsWith("toolcall_") ? "tool_call" : void 0;
+  if (expectedType !== void 0) {
+    for (let index = parts.length - 1; index >= 0; index--) {
+      if (parts[index]?.type === expectedType)
+        return index;
+    }
+  }
+  return parts.length;
+}
+function applyMessageDeltaPart(current, delta, deltaType, contentIndex) {
+  switch (deltaType) {
+    case "text_start": {
+      const declared = parseContentPart(delta["block"]).find((part) => part.type === "text");
+      return declared ?? { type: "text", text: "" };
+    }
+    case "text_delta": {
+      const chunk = getString(delta, "delta");
+      if (chunk === void 0)
+        return current;
+      const previous = current?.type === "text" ? current.text : "";
+      return {
+        ...current?.type === "text" ? current : { type: "text" },
+        text: sanitizeAssistantText(previous + chunk)
+      };
+    }
+    case "text_end": {
+      const content = getString(delta, "content");
+      return content === void 0 ? current : parseContentPart({
+        type: "text",
+        text: content,
+        textSignature: getString(delta, "contentSignature")
+      }).find((part) => part.type === "text") ?? current;
+    }
+    case "thinking_start":
+      return { type: "thinking", text: "" };
+    case "thinking_delta": {
+      const chunk = getString(delta, "delta");
+      if (chunk === void 0)
+        return current;
+      const previous = current?.type === "thinking" ? current.text : "";
+      return { type: "thinking", text: previous + chunk };
+    }
+    case "thinking_end": {
+      const content = getString(delta, "content");
+      return content === void 0 ? current : { type: "thinking", text: content };
+    }
+    case "toolcall_start": {
+      const toolCallId = getToolCallId(delta);
+      if (toolCallId === void 0)
+        return current;
+      return {
+        type: "tool_call",
+        toolCallId,
+        ...stringField("name", getToolName(delta)),
+        argumentsText: ""
+      };
+    }
+    case "toolcall_delta": {
+      const chunk = getString(delta, "delta");
+      if (chunk === void 0 || current?.type !== "tool_call")
+        return current;
+      return {
+        ...current,
+        argumentsText: (current.argumentsText ?? "") + chunk
+      };
+    }
+    case "toolcall_end": {
+      const completed = parseContentPart(delta["toolCall"]).find((part) => part.type === "tool_call");
+      return completed ?? current;
+    }
+    default:
+      return current ?? {
+        type: "unknown",
+        providerType: deltaType,
+        value: { ...delta, contentIndex }
+      };
+  }
+}
+function messageAttemptContext(item) {
+  return {
+    sourceMessageId: item.id,
+    responseId: item.responseId ?? item.id
+  };
+}
+function hasMessageError(event) {
+  const record = asRecord2(event);
+  if (record === void 0)
+    return false;
+  const stopReason = getStringPath(record, ["message", "stopReason"]) ?? getStringPath(record, ["entry", "stopReason"]) ?? getString(record, "stopReason");
+  return stopReason === "error" || getErrorText(record) !== void 0;
+}
+function messageMetadata(event, textPhase, parts = extractContentParts(event)) {
+  const finishReason = finishReasonFor(event, parts);
+  return {
+    ...stringField("responseId", getResponseId(event)),
+    ...finishReason === void 0 ? {} : { finishReason },
+    ...textPhase === void 0 ? {} : { textPhase },
+    ...stringField("provider", getProvider(event)),
+    ...stringField("adapter", getAdapter(event)),
+    ...stringField("model", getModel(event)),
+    ...finishReason === "error" ? messageFailureReason(event) : {}
+  };
+}
+function messageFailureReason(event) {
+  const record = asRecord2(event);
+  if (record === void 0)
+    return {};
+  const message = asRecord2(record["message"]) ?? asRecord2(record["entry"]) ?? record;
+  const diagnostics = message["diagnostics"];
+  const failure = readRunFailureOccurrence(Array.isArray(diagnostics) ? { diagnostics } : {});
+  const errorText = getErrorText(record);
+  return {
+    ...failure === void 0 ? {} : { failure },
+    failureReason: failure?.cause.reason ?? "unknown",
+    ...errorText === void 0 ? {} : { failureText: readableFailureText(errorText) }
+  };
+}
+function textPhaseFor(event, parts) {
+  if (event.type !== "message_end")
+    return "provisional";
+  switch (finishReasonFor(event, parts)) {
+    case "tool_use":
+      return "narration";
+    case "complete":
+      return "final";
+    case "interrupted":
+    case "cancelled":
+      return "interrupted";
+    case "error":
+      return "error";
+    case "unknown":
+      return parts.some((part) => part.type === "tool_call") ? "narration" : "final";
+    case void 0:
+      return "final";
+  }
+}
+function finishReasonFor(event, parts) {
+  const raw = getStringPath(event, ["message", "stopReason"]) ?? getStringPath(event, ["entry", "stopReason"]) ?? getString(event, "stopReason");
+  if (raw !== void 0)
+    return normalizeFinishReason(raw);
+  if (event.type !== "message_end")
+    return void 0;
+  if (hasMessageError(event))
+    return "error";
+  return parts.some((part) => part.type === "tool_call") ? "tool_use" : "complete";
+}
+function normalizeFinishReason(value) {
+  switch (value) {
+    case "toolUse":
+    case "tool_use":
+    case "tool-use":
+      return "tool_use";
+    case "stop":
+    case "complete":
+    case "completed":
+    case "end_turn":
+      return "complete";
+    case "abort":
+    case "aborted":
+    case "interrupted":
+      return "interrupted";
+    case "cancel":
+    case "cancelled":
+    case "canceled":
+      return "cancelled";
+    case "error":
+    case "failed":
+      return "error";
+    default:
+      return "unknown";
+  }
+}
+function reduceToolExecution(state, event, status, replay) {
+  const toolCallId = getToolCallId(event);
+  if (toolCallId === void 0)
+    return state;
+  return upsertToolCall(state, {
+    toolCallId,
+    status,
+    ...stringField("name", getToolName(event)),
+    ...activityKindsField(event),
+    ...stringField("argumentsText", getArgumentsText(event)),
+    ...stringField("resultText", getResultText(event)),
+    ...stringField("errorText", getErrorText(event)),
+    ...toolCallFailureField(event),
+    ...unknownField("resultDetails", getPath(asRecord2(event) ?? {}, ["details"])),
+    ...stringField("startedAt", status === "running" ? getTimestamp(event) : void 0),
+    ...stringField("completedAt", status === "complete" || status === "error" ? getTimestamp(event) : void 0)
+  }, {
+    forceNewAttempt: event.type === "tool_execution_start" && state.pendingToolsByCallId[toolCallId] === void 0
+  }, replay);
+}
+function normalizeToolExecutionCompletion(event) {
+  const record = asRecord2(event);
+  const result = asRecord2(record?.["result"]);
+  const toolCallId = getToolCallId(event);
+  if (toolCallId === void 0)
+    return void 0;
+  const isError = record?.["isError"] === true || getErrorText(event) !== void 0;
+  const resultText = getResultText(result) ?? getResultText(event);
+  const errorText = isError ? getErrorText(event) ?? resultText : void 0;
+  const resultDetails = result !== void 0 && Object.hasOwn(result, "details") ? result["details"] : record?.["details"];
+  return {
+    toolCallId,
+    ...stringField("entryId", getEntryId(event)),
+    ...stringField("name", getToolName(event)),
+    ...stringField("resultText", resultText),
+    ...unknownField("resultDetails", resultDetails),
+    isError,
+    ...stringField("errorText", errorText),
+    ...toolCallFailureField(event),
+    ...stringField("completedAt", getTimestamp(event))
+  };
+}
+function reduceToolCompletion(state, completion, replay) {
+  if (completion === void 0)
+    return state;
+  const status = completion.isError ? completion.failure?.cause.category === "cancelled" || state.run.status === "aborted" ? "interrupted" : "error" : "complete";
+  const withTool = upsertToolCall(state, {
+    toolCallId: completion.toolCallId,
+    status,
+    ...stringField("name", completion.name),
+    ...stringField("resultText", completion.resultText),
+    ...unknownField("resultDetails", completion.resultDetails),
+    ...stringField("resultEntryId", completion.entryId),
+    ...stringField("errorText", completion.errorText),
+    ...completion.failure === void 0 ? {} : { failure: completion.failure },
+    ...stringField("completedAt", status === "complete" || status === "error" ? completion.completedAt : void 0)
+  }, {}, replay);
+  if (completion.entryId === void 0)
+    return withTool;
+  const tool = findToolItemByCallId(withTool, completion.toolCallId, replay);
+  if (tool?.sourceMessageId === void 0)
+    return withTool;
+  const source = findMessageItem(withTool, tool.sourceMessageId, replay);
+  if (source?.role !== "assistant")
+    return withTool;
+  return upsertMessageItem(withTool, { ...source, forkEntryId: completion.entryId }, replay);
+}
+function reduceToolResultMessage(state, event, replay) {
+  const body = getPath(asRecord2(event) ?? {}, ["message"]) ?? getPath(asRecord2(event) ?? {}, ["entry"]) ?? event;
+  return reduceToolCompletion(state, normalizeToolResultMessageCompletion(body, getTimestamp(event), getEntryId(event)), replay);
+}
+function normalizeToolResultMessageCompletion(body, completedAt, entryId) {
+  const record = asRecord2(body);
+  const toolCallId = getToolCallId(body);
+  if (record === void 0 || toolCallId === void 0)
+    return void 0;
+  const isError = record["isError"] === true || getErrorText(record) !== void 0;
+  const resultText = getResultText(record);
+  return {
+    toolCallId,
+    ...stringField("entryId", entryId),
+    ...stringField("name", getToolName(record)),
+    ...stringField("resultText", resultText),
+    ...unknownField("resultDetails", record["details"]),
+    isError,
+    ...stringField("errorText", isError ? getErrorText(record) ?? resultText : void 0),
+    ...toolCallFailureField(record),
+    ...stringField("completedAt", completedAt)
+  };
+}
+function reduceBackgroundTask(state, event, status, replay) {
+  const taskId = getString(event, "taskId");
+  const toolCallId = getString(event, "toolCallId");
+  const taskKind = getString(event, "taskKind");
+  if (taskId === void 0 || toolCallId === void 0 || taskKind === void 0) {
+    return state;
+  }
+  const previous = state.backgroundTasksById[taskId];
+  const ownerId = getString(event, "ownerId") ?? previous?.ownerId;
+  const text = getString(event, "text") ?? previous?.text;
+  const output = getString(event, "output") ?? previous?.output;
+  const errorText = getErrorText(event) ?? previous?.errorText;
+  const snapshot = asRecord2(event)?.["snapshot"] ?? previous?.snapshot;
+  const nextTask = {
+    taskId,
+    taskKind,
+    toolCallId,
+    status,
+    ...stringField("ownerId", ownerId),
+    ...stringField("text", text),
+    ...stringField("output", output),
+    ...stringField("errorText", errorText),
+    ...snapshot !== void 0 ? { snapshot } : {}
+  };
+  const withTask = {
+    ...state,
+    backgroundTasksById: {
+      ...state.backgroundTasksById,
+      [taskId]: nextTask
+    }
+  };
+  return upsertToolCall(withTask, {
+    toolCallId,
+    status: toToolStatus(status),
+    backgroundTaskId: taskId,
+    ...stringField("resultText", getString(event, "output")),
+    ...stringField("errorText", getErrorText(event))
+  }, {}, replay);
+}
+function reduceCustomEntry(state, event) {
+  const customType = getString(event, "customType");
+  if (customType === void 0)
+    return state;
+  const data = asRecord2(event)?.data;
+  if (data === void 0)
+    return state;
+  const previous = state.customEntries[customType] ?? [];
+  return {
+    ...state,
+    customEntries: {
+      ...state.customEntries,
+      [customType]: [...previous, data]
+    }
+  };
+}
+function toToolStatus(status) {
+  switch (status) {
+    case "running":
+      return "running";
+    case "complete":
+      return "complete";
+    case "cancelled":
+      return "cancelled";
+    case "failed":
+      return "error";
+  }
+}
+function stringField(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function unknownField(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function activityKindsField(value) {
+  const raw = asRecord2(value)?.["activityKinds"];
+  if (!Array.isArray(raw))
+    return {};
+  const activityKinds = raw.filter((kind) => typeof kind === "string" && TOOL_ACTIVITY_KINDS.has(kind));
+  return activityKinds.length === 0 ? {} : { activityKinds };
+}
+function withSessionName(state, sessionName) {
+  const { sessionName: _previousSessionName, ...rest } = state;
+  void _previousSessionName;
+  return {
+    ...rest,
+    ...stringField("sessionName", sessionName)
+  };
+}
+function markAbortedAssistant(state, replay) {
+  for (let index = state.items.length - 1; index >= 0; index -= 1) {
+    const item = state.items[index];
+    if (item?.type !== "message")
+      continue;
+    if (item.role === "user" && item.deliveredVia !== "steer")
+      return state;
+    if (item.role !== "assistant")
+      continue;
+    if (item.finishReason !== "tool_use" || item.runAborted)
+      return state;
+    return upsertMessageItem(state, { ...item, runAborted: true }, replay);
+  }
+  return state;
+}
+function clearTransientState(state, run, terminal, replay) {
+  const terminalized = terminalizeOpenItems(state, terminal, replay);
+  if (terminalized === state && replay !== void 0) {
+    for (const key of Object.keys(replay.pendingToolsByCallId)) {
+      delete replay.pendingToolsByCallId[key];
+    }
+    return {
+      ...withoutStreamingAssistant(state),
+      pendingToolsByCallId: replay.pendingToolsByCallId,
+      run
+    };
+  }
+  return resetReplayIndex(replay, {
+    ...withoutStreamingAssistant(terminalized),
+    pendingToolsByCallId: {},
+    run
+  });
+}
+function terminalizeMessageItems(state, sourceMessageId, terminal, replay) {
+  const terminalizedCallIds = /* @__PURE__ */ new Set();
+  const closes = (item) => item.type === "tool" && item.sourceMessageId === sourceMessageId && isClosable(state, item);
+  let items;
+  if (replay === void 0) {
+    items = state.items.map((item) => {
+      if (!closes(item))
+        return item;
+      terminalizedCallIds.add(item.toolCallId);
+      return closedTool(item, terminal);
+    });
+  } else {
+    for (const index of Array.from(replay.openItemIndexes)) {
+      const item = replay.items[index];
+      if (item === void 0 || !closes(item))
+        continue;
+      terminalizedCallIds.add(item.toolCallId);
+      writeClosedReplayItem(replay, index, closedTool(item, terminal));
+    }
+    items = replay.items;
+  }
+  const pendingToolsByCallId = Object.fromEntries(Object.entries(state.pendingToolsByCallId).filter(([toolCallId]) => !terminalizedCallIds.has(toolCallId)));
+  return resetReplayIndex(replay, {
+    ...withoutStreamingAssistant(state),
+    items,
+    pendingToolsByCallId
+  });
+}
+function terminalizeOpenItems(state, terminal, replay) {
+  let changed = false;
+  if (replay !== void 0) {
+    for (const index of Array.from(replay.openItemIndexes)) {
+      const item = replay.items[index];
+      if (item === void 0 || !isClosable(state, item))
+        continue;
+      changed = true;
+      writeClosedReplayItem(replay, index, closedItem(item, terminal));
+    }
+    return changed ? { ...state, items: replay.items } : state;
+  }
+  const items = state.items.map((item) => {
+    if (!isClosable(state, item))
+      return item;
+    changed = true;
+    return closedItem(item, terminal);
+  });
+  return changed ? { ...state, items } : state;
+}
+function isOpenItem(item) {
+  return item.type === "message" ? item.status === "streaming" : !isTerminalToolStatus(item.status);
+}
+function isClosable(state, item) {
+  return isOpenItem(item) && (item.type === "message" || !isRunningBackgroundTool(state, item));
+}
+function closedItem(item, terminal) {
+  if (item.type === "tool")
+    return closedTool(item, terminal);
+  return {
+    ...item,
+    status: terminal.status,
+    finishReason: terminal.status,
+    textPhase: terminal.status
+  };
+}
+function closedTool(item, terminal) {
+  return {
+    ...item,
+    status: terminal.status,
+    ...terminal.errorText === void 0 ? {} : { errorText: terminal.errorText }
+  };
+}
+function isRunningBackgroundTool(state, item) {
+  if (item.backgroundTaskId === void 0)
+    return false;
+  return state.backgroundTasksById[item.backgroundTaskId]?.status === "running";
+}
+function isTerminalToolStatus(status) {
+  return status === "complete" || status === "interrupted" || status === "cancelled" || status === "error";
+}
+function withoutStreamingAssistant(state) {
+  const { streamingAssistantId: _streamingAssistantId, ...rest } = state;
+  void _streamingAssistantId;
+  return rest;
+}
+function createReplayIndex(state) {
+  const replay = {
+    items: [...state.items],
+    messageIndexById: /* @__PURE__ */ new Map(),
+    toolIndexById: /* @__PURE__ */ new Map(),
+    toolIndexByAttemptId: /* @__PURE__ */ new Map(),
+    latestToolIndexByCallId: /* @__PURE__ */ new Map(),
+    maxToolGenerationByCallId: /* @__PURE__ */ new Map(),
+    pendingToolsByCallId: { ...state.pendingToolsByCallId },
+    openItemIndexes: /* @__PURE__ */ new Set(),
+    latestToolIndexBehind: false
+  };
+  indexReplayItems(replay);
+  return replay;
+}
+function resetReplayIndex(replay, state) {
+  if (replay === void 0)
+    return state;
+  const copied = state.items !== replay.items;
+  if (copied) {
+    replay.items.length = 0;
+    for (const item of state.items)
+      replay.items.push(item);
+  }
+  for (const key of Object.keys(replay.pendingToolsByCallId)) {
+    delete replay.pendingToolsByCallId[key];
+  }
+  Object.assign(replay.pendingToolsByCallId, state.pendingToolsByCallId);
+  if (copied || replay.latestToolIndexBehind)
+    indexReplayItems(replay);
+  return {
+    ...state,
+    items: replay.items,
+    pendingToolsByCallId: replay.pendingToolsByCallId
+  };
+}
+function indexReplayItems(replay) {
+  replay.messageIndexById.clear();
+  replay.toolIndexById.clear();
+  replay.toolIndexByAttemptId.clear();
+  replay.latestToolIndexByCallId.clear();
+  replay.maxToolGenerationByCallId.clear();
+  replay.openItemIndexes.clear();
+  replay.latestToolIndexBehind = false;
+  replay.items.forEach((item, index) => indexReplayItem(replay, item, index));
+}
+function indexReplayItem(replay, item, index) {
+  if (isOpenItem(item))
+    replay.openItemIndexes.add(index);
+  else
+    replay.openItemIndexes.delete(index);
+  if (item.type === "message") {
+    replay.messageIndexById.set(item.id, index);
+    return;
+  }
+  replay.toolIndexById.set(item.id, index);
+  if (item.attemptId !== void 0) {
+    replay.toolIndexByAttemptId.set(item.attemptId, index);
+  }
+  const latest = replay.latestToolIndexByCallId.get(item.toolCallId);
+  if (latest !== void 0 && latest > index) {
+    replay.latestToolIndexBehind = true;
+  }
+  replay.latestToolIndexByCallId.set(item.toolCallId, index);
+  replay.maxToolGenerationByCallId.set(item.toolCallId, Math.max(replay.maxToolGenerationByCallId.get(item.toolCallId) ?? 0, item.attemptGeneration ?? 0));
+}
+function writeClosedReplayItem(replay, index, item) {
+  replay.items[index] = item;
+  replay.openItemIndexes.delete(index);
+}
+function replaceReplayItem(replay, index, item) {
+  const previous = replay.items[index];
+  replay.items[index] = item;
+  if (previous?.type === "tool" && item.type === "tool" && (previous.toolCallId !== item.toolCallId || previous.attemptId !== item.attemptId || previous.attemptGeneration !== item.attemptGeneration)) {
+    indexReplayItems(replay);
+    return;
+  }
+  indexReplayItem(replay, item, index);
+}
+function upsertMessageItem(state, item, replay) {
+  const itemIndex = replay === void 0 ? state.items.findIndex((candidate) => candidate.type === "message" && candidate.id === item.id) : replay.messageIndexById.get(item.id) ?? -1;
+  if (itemIndex === -1) {
+    if (replay !== void 0) {
+      const index = replay.items.length;
+      replay.items.push(item);
+      indexReplayItem(replay, item, index);
+    }
+    return {
+      ...state,
+      items: replay?.items ?? [...state.items, item],
+      nextItemIndex: nextItemIndexAfter(state, item.id)
+    };
+  }
+  return replaceMessageItem(state, item, replay);
+}
+function replaceMessageItem(state, item, replay) {
+  if (replay !== void 0) {
+    const itemIndex = replay.messageIndexById.get(item.id);
+    if (itemIndex !== void 0)
+      replaceReplayItem(replay, itemIndex, item);
+  }
+  return {
+    ...state,
+    items: replay?.items ?? state.items.map((candidate) => candidate.type === "message" && candidate.id === item.id ? item : candidate)
+  };
+}
+function upsertToolCalls(state, toolCalls, status = "declared", context, replay) {
+  return toolCalls.reduce((nextState, toolCall) => upsertToolCall(nextState, {
+    ...toolCall,
+    status,
+    ...context
+  }, {}, replay), state);
+}
+function upsertToolCall(state, update, options = {}, replay) {
+  const declaredAttemptId = update.sourceMessageId === void 0 ? void 0 : canonicalAttemptId(update.responseId ?? update.sourceMessageId, update.ordinal ?? 0);
+  const declaredCandidate = declaredAttemptId === void 0 ? void 0 : findToolItemByAttemptId(state, declaredAttemptId, replay);
+  const declaredConflict = declaredCandidate !== void 0 && declaredCandidate.toolCallId !== void 0 && declaredCandidate.toolCallId !== update.toolCallId;
+  const declaredMatch = declaredConflict ? void 0 : declaredCandidate;
+  const usableDeclaredAttemptId = declaredConflict ? void 0 : declaredAttemptId;
+  const pendingItemId = declaredMatch?.id ?? state.pendingToolsByCallId[update.toolCallId];
+  const settledMatch = pendingItemId === void 0 && options.forceNewAttempt !== true ? findToolItemByCallId(state, update.toolCallId, replay) : void 0;
+  const foldableMatch = settledMatch !== void 0 && (update.sourceMessageId === void 0 || settledMatch.sourceMessageId === update.sourceMessageId) && settledMatch.status === "error" === (update.status === "error") ? settledMatch : void 0;
+  const matched = declaredMatch ?? (pendingItemId === void 0 ? void 0 : findToolItem(state, pendingItemId, replay)) ?? foldableMatch;
+  const attemptGeneration = matched?.attemptGeneration ?? nextAttemptGeneration(state, update.toolCallId, replay);
+  const responseId = update.responseId ?? matched?.responseId;
+  const sourceMessageId = update.sourceMessageId ?? matched?.sourceMessageId;
+  const waveId = matched?.waveId ?? canonicalWaveId(responseId ?? sourceMessageId ?? "unscoped");
+  const attemptId = usableDeclaredAttemptId ?? matched?.attemptId ?? canonicalExecutionAttemptId("unscoped", update.toolCallId, attemptGeneration);
+  const itemId = matched?.id ?? attemptId;
+  const previous = findToolItem(state, itemId, replay);
+  const name = update.name ?? previous?.name;
+  const activityKinds = update.activityKinds ?? previous?.activityKinds;
+  const argumentsText = previous?.argumentsText !== void 0 && isEmptyStructuredArguments(update.argumentsText) ? previous.argumentsText : update.argumentsText ?? previous?.argumentsText;
+  const resultText = update.resultText ?? previous?.resultText;
+  const resultDetails = update.resultDetails !== void 0 ? update.resultDetails : previous?.resultDetails;
+  const errorText = update.errorText ?? previous?.errorText;
+  const failure = update.failure ?? previous?.failure;
+  const backgroundTaskId = update.backgroundTaskId ?? previous?.backgroundTaskId;
+  const startedAt = update.startedAt ?? previous?.startedAt;
+  const completedAt = update.completedAt ?? previous?.completedAt;
+  const nextItem = {
+    id: itemId,
+    type: "tool",
+    toolCallId: update.toolCallId,
+    status: update.status,
+    attemptId,
+    waveId,
+    attemptGeneration,
+    ...stringField("name", name),
+    ...activityKinds === void 0 ? {} : { activityKinds },
+    ...stringField("argumentsText", argumentsText),
+    ...stringField("resultText", resultText),
+    ...unknownField("resultDetails", resultDetails),
+    ...stringField("resultEntryId", update.resultEntryId ?? previous?.resultEntryId),
+    ...stringField("errorText", errorText),
+    ...failure === void 0 ? {} : { failure },
+    ...stringField("backgroundTaskId", backgroundTaskId),
+    ...stringField("responseId", responseId),
+    ...stringField("sourceMessageId", sourceMessageId),
+    ...stringField("startedAt", startedAt),
+    ...stringField("completedAt", completedAt)
+  };
+  let items;
+  if (replay === void 0) {
+    items = previous === void 0 ? [...state.items, nextItem] : state.items.map((candidate) => candidate.type === "tool" && candidate.id === itemId ? nextItem : candidate);
+  } else if (previous === void 0) {
+    const index = replay.items.length;
+    replay.items.push(nextItem);
+    indexReplayItem(replay, nextItem, index);
+    items = replay.items;
+  } else {
+    const index = replay.toolIndexById.get(itemId);
+    if (index !== void 0)
+      replaceReplayItem(replay, index, nextItem);
+    items = replay.items;
+  }
+  let pendingToolsByCallId;
+  if (replay === void 0) {
+    pendingToolsByCallId = isTerminalToolStatus(update.status) ? omitKey(state.pendingToolsByCallId, update.toolCallId) : {
+      ...state.pendingToolsByCallId,
+      [update.toolCallId]: itemId
+    };
+  } else {
+    if (isTerminalToolStatus(update.status)) {
+      delete replay.pendingToolsByCallId[update.toolCallId];
+    } else {
+      replay.pendingToolsByCallId[update.toolCallId] = itemId;
+    }
+    pendingToolsByCallId = replay.pendingToolsByCallId;
+  }
+  return {
+    ...state,
+    items,
+    pendingToolsByCallId,
+    nextItemIndex: previous === void 0 ? nextItemIndexAfter(state, itemId) : state.nextItemIndex
+  };
+}
+function isEmptyStructuredArguments(value) {
+  const trimmed = value?.trim();
+  return trimmed === "{}" || trimmed === "[]";
+}
+function findToolItemByAttemptId(state, attemptId, replay) {
+  if (replay !== void 0) {
+    const replayIndex = replay.toolIndexByAttemptId.get(attemptId);
+    const item = replayIndex === void 0 ? void 0 : replay.items[replayIndex];
+    return item?.type === "tool" ? item : void 0;
+  }
+  return state.items.find((candidate) => candidate.type === "tool" && candidate.attemptId === attemptId);
+}
+function nextAttemptGeneration(state, toolCallId, replay) {
+  if (replay !== void 0) {
+    return (replay.maxToolGenerationByCallId.get(toolCallId) ?? 0) + 1;
+  }
+  return state.items.reduce((highest, item) => item.type === "tool" && item.toolCallId === toolCallId ? Math.max(highest, item.attemptGeneration ?? 0) : highest, 0) + 1;
+}
+function canonicalWaveId(responseId) {
+  return `tool-wave:${encodeURIComponent(responseId)}`;
+}
+function canonicalAttemptId(sourceMessageId, ordinal) {
+  return `tool-attempt:${encodeURIComponent(sourceMessageId)}:${ordinal}`;
+}
+function canonicalExecutionAttemptId(turnId, toolCallId, generation) {
+  return `tool-attempt:${encodeURIComponent(turnId)}:${encodeURIComponent(toolCallId)}:${generation}`;
+}
+function findMessageItem(state, itemId, replay) {
+  if (replay !== void 0) {
+    const replayIndex = replay.messageIndexById.get(itemId);
+    const item = replayIndex === void 0 ? void 0 : replay.items[replayIndex];
+    return item?.type === "message" ? item : void 0;
+  }
+  return state.items.find((candidate) => candidate.type === "message" && candidate.id === itemId);
+}
+function findToolItem(state, itemId, replay) {
+  if (replay !== void 0) {
+    const replayIndex = replay.toolIndexById.get(itemId);
+    const item = replayIndex === void 0 ? void 0 : replay.items[replayIndex];
+    return item?.type === "tool" ? item : void 0;
+  }
+  return state.items.find((candidate) => candidate.type === "tool" && candidate.id === itemId);
+}
+function findToolItemByCallId(state, toolCallId, replay) {
+  if (replay !== void 0) {
+    const replayIndex = replay.latestToolIndexByCallId.get(toolCallId);
+    const item = replayIndex === void 0 ? void 0 : replay.items[replayIndex];
+    return item?.type === "tool" ? item : void 0;
+  }
+  for (let i = state.items.length - 1; i >= 0; i--) {
+    const candidate = state.items[i];
+    if (candidate?.type === "tool" && candidate.toolCallId === toolCallId) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+function allocateItemId(state, prefix) {
+  return `${prefix}-${state.nextItemIndex}`;
+}
+function nextItemIndexAfter(state, itemId) {
+  const suffix = Number(itemId.match(/-(\d+)$/)?.[1]);
+  return Number.isFinite(suffix) ? Math.max(state.nextItemIndex, suffix + 1) : state.nextItemIndex + 1;
+}
+function extractQueuedMessages(event) {
+  const candidates = [
+    getArray(event, "queue"),
+    getArray(event, "messages"),
+    getArray(event, "pendingMessages")
+  ].find((value) => value !== void 0);
+  if (candidates === void 0)
+    return [];
+  return candidates.map((candidate, index) => {
+    const record = asRecord2(candidate);
+    return {
+      id: getQueuedMessageId(record, index),
+      text: getQueuedMessageText(candidate, record),
+      ...stringField("channel", getQueuedMessageChannel(record))
+    };
+  });
+}
+function reduceManagedHumanQueueUpdate(state, event) {
+  const snapshot = asRecord2(getPath(event, ["snapshot"]));
+  const revision = snapshot === void 0 ? void 0 : getNumber(snapshot, "revision");
+  const rawItems = snapshot === void 0 ? void 0 : getArray(snapshot, "items");
+  const queue = (rawItems ?? []).flatMap((candidate, index) => {
+    const record = asRecord2(candidate);
+    if (record === void 0)
+      return [];
+    const id = getString(record, "id") ?? `queue-${index + 1}`;
+    const text = getString(record, "text") ?? "";
+    const channel = getString(record, "channel");
+    const status = getString(record, "status");
+    const clientIntentId = getString(record, "clientIntentId");
+    const presentationAnchor = getPresentationAnchor(record);
+    const attachments = getArray(record, "attachments")?.flatMap((ref) => {
+      const uri = getString(ref, "uri");
+      const name = getString(ref, "name");
+      const mimeType = getString(ref, "mimeType");
+      return uri === void 0 || name === void 0 || mimeType === void 0 ? [] : [{ uri, name, mimeType }];
+    });
+    const context = extractQueuedMessageContext(record);
+    const resendError = getString(record, "resendError");
+    return [
+      {
+        id,
+        text,
+        ...channel !== void 0 ? { channel } : {},
+        ...clientIntentId !== void 0 ? { clientIntentId } : {},
+        ...presentationAnchor === void 0 ? {} : { presentationAnchor },
+        ...attachments === void 0 || attachments.length === 0 ? {} : { attachments },
+        ...context === void 0 ? {} : { context },
+        ...resendError === void 0 ? {} : { resendError },
+        ...status === "queued" || status === "editing" ? { status } : {}
+      }
+    ];
+  });
+  return {
+    ...state,
+    queue,
+    ...revision !== void 0 ? { queueRevision: revision } : {}
+  };
+}
+function extractQueuedMessageContext(record) {
+  const raw = getArray(record, "context");
+  if (raw === void 0)
+    return void 0;
+  return raw.flatMap((candidate) => {
+    const part = asRecord2(candidate);
+    if (part === void 0)
+      return [];
+    const kind = getString(part, "kind");
+    if (kind === "tab_context" || kind === "ui_action") {
+      const bodyOrAction = getString(part, kind === "tab_context" ? "body" : "action");
+      const surfaceOrToolCallId = getString(part, kind === "tab_context" ? "surface" : "toolCallId");
+      const payload = kind === "ui_action" ? getString(part, "payload") : void 0;
+      return bodyOrAction === void 0 || surfaceOrToolCallId === void 0 || kind === "ui_action" && payload === void 0 ? [] : [
+        kind === "tab_context" ? { kind, body: bodyOrAction, surface: surfaceOrToolCallId } : {
+          kind,
+          action: bodyOrAction,
+          toolCallId: surfaceOrToolCallId,
+          payload
+        }
+      ];
+    }
+    if (kind === "composer_references") {
+      const mentions = getArray(part, "mentions")?.flatMap((value) => {
+        const mention = asRecord2(value);
+        if (mention === void 0)
+          return [];
+        const ref = getString(mention, "ref");
+        const serviceId = getString(mention, "serviceId");
+        const entityType = getString(mention, "entityType");
+        return ref === void 0 || serviceId === void 0 || entityType === void 0 ? [] : [{ ref, serviceId, entityType }];
+      });
+      const invocations = getArray(part, "invocations")?.flatMap((value) => {
+        const invocation = asRecord2(value);
+        if (invocation === void 0)
+          return [];
+        const id = getString(invocation, "id");
+        const serviceId = getString(invocation, "serviceId");
+        return id === void 0 || serviceId === void 0 ? [] : [{ id, serviceId }];
+      });
+      return mentions === void 0 || invocations === void 0 ? [] : [{ kind, mentions, invocations }];
+    }
+    if (kind === "user_pasted_content") {
+      const items = getArray(part, "items")?.flatMap((value) => {
+        const item = asRecord2(value);
+        if (item === void 0)
+          return [];
+        const id = getString(item, "id");
+        const lineCount = getNumber(item, "lineCount");
+        const text = getString(item, "text");
+        const attachment = asRecord2(item["attachment"]);
+        const name = attachment === void 0 ? void 0 : getString(attachment, "name");
+        const uri = attachment === void 0 ? void 0 : getString(attachment, "uri");
+        if (id === void 0 || lineCount === void 0)
+          return [];
+        if (text !== void 0 && attachment === void 0)
+          return [
+            {
+              id,
+              lineCount,
+              text,
+              // Strict `=== true`, so a malformed rehydrated value drops the
+              // provenance claim rather than fabricating one.
+              ...item["inline"] === true ? { inline: true } : {}
+            }
+          ];
+        if (text === void 0 && name !== void 0) {
+          return [
+            {
+              id,
+              lineCount,
+              attachment: { name, ...uri === void 0 ? {} : { uri } }
+            }
+          ];
+        }
+        return [];
+      });
+      return items === void 0 ? [] : [{ kind, items }];
+    }
+    return [];
+  });
+}
+function getQueuedMessageId(record, index) {
+  if (record === void 0)
+    return `queue-${index + 1}`;
+  return getString(record, "id") ?? getString(record, "messageId") ?? `queue-${index + 1}`;
+}
+function getQueuedMessageText(candidate, record) {
+  if (record !== void 0)
+    return extractText(record);
+  return typeof candidate === "string" ? candidate : "";
+}
+function getQueuedMessageChannel(record) {
+  if (record === void 0)
+    return void 0;
+  return getString(record, "channel") ?? getString(record, "type");
+}
+var STREAM_MARKER_PATTERN = /(?:<\|(?:eot_id|end_of_turn|endoftext|im_end|eom|bom|eot|end)\|>)/giu;
+function sanitizeAssistantText(text) {
+  return text.replace(STREAM_MARKER_PATTERN, "");
+}
+function sanitizeAssistantContentParts(parts) {
+  return parts.map((part) => part.type === "text" ? { ...part, text: sanitizeAssistantText(part.text) } : part);
+}
+function textFromContentParts(parts) {
+  return parts.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
+}
+function extractContentParts(event) {
+  const parts = extractMessageContentParts(event);
+  if (parts.length > 0)
+    return parts;
+  const text = extractText(event);
+  const fallbackParts = text === "" ? [] : [{ type: "text", text }];
+  for (const toolCall of extractToolCalls(event)) {
+    fallbackParts.push({
+      type: "tool_call",
+      toolCallId: toolCall.toolCallId,
+      ...stringField("name", toolCall.name),
+      ...stringField("argumentsText", toolCall.argumentsText)
+    });
+  }
+  return fallbackParts;
+}
+function extractMessageContentParts(event) {
+  const content = firstArray([
+    getPath(event, ["message", "content"]),
+    getPath(event, ["entry", "message", "content"]),
+    getPath(event, ["entry", "content"]),
+    getPath(event, ["partial", "content"]),
+    getPath(event, ["assistantMessageEvent", "partial", "content"]),
+    getPath(event, ["assistantMessageEvent", "message", "content"]),
+    getPath(event, ["assistantMessageEvent", "error", "content"]),
+    getPath(event, ["assistantMessageEvent", "content"]),
+    getPath(event, ["content"])
+  ]);
+  if (content === void 0)
+    return [];
+  return content.flatMap(parseContentPart);
+}
+function parseContentPart(part) {
+  const record = asRecord2(part);
+  if (record === void 0)
+    return [];
+  switch (getString(record, "type")) {
+    case "text":
+      return textContentPart(getString(record, "text"), decodeDeclaredPhase(getString(record, "textSignature")));
+    case "thinking":
+      return thinkingContentPart(record);
+    case "toolCall":
+    case "tool_call":
+      return toolCallContentPart(record);
+    default:
+      return [
+        {
+          type: "unknown",
+          ...stringField("providerType", getString(record, "type")),
+          value: part
+        }
+      ];
+  }
+}
+function textContentPart(text, declaredPhase) {
+  if (text === void 0 || text === "")
+    return [];
+  return [
+    {
+      type: "text",
+      text,
+      ...declaredPhase === void 0 ? {} : { declaredPhase }
+    }
+  ];
+}
+function decodeDeclaredPhase(signature) {
+  if (signature === void 0 || !signature.startsWith("{"))
+    return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(signature);
+  } catch {
+    return void 0;
+  }
+  const phase = asRecord2(parsed)?.["phase"];
+  if (phase === "commentary")
+    return "narration";
+  if (phase === "final_answer")
+    return "final";
+  return void 0;
+}
+function thinkingContentPart(record) {
+  const text = getString(record, "thinking") ?? getString(record, "text") ?? getString(record, "content");
+  return text === void 0 || text === "" ? [] : [{ type: "thinking", text }];
+}
+function toolCallContentPart(record) {
+  const toolCallId = getToolCallId(record);
+  if (toolCallId === void 0)
+    return [];
+  return [
+    {
+      type: "tool_call",
+      toolCallId,
+      ...stringField("name", getToolName(record)),
+      ...stringField("argumentsText", getArgumentsText(record))
+    }
+  ];
+}
+function extractToolCalls(event) {
+  const seen = /* @__PURE__ */ new Set();
+  const toolCalls = [];
+  visit(event, (value) => {
+    const record = asRecord2(value);
+    if (record === void 0)
+      return;
+    const toolCallId = getToolCallId(record);
+    if (toolCallId === void 0 || seen.has(toolCallId))
+      return;
+    const name = getToolName(record);
+    const argumentsText = getArgumentsText(record);
+    const hasToolDetails = name !== void 0 || argumentsText !== void 0 || looksLikeToolCall(record);
+    if (!hasToolDetails) {
+      return;
+    }
+    seen.add(toolCallId);
+    toolCalls.push({
+      toolCallId,
+      ordinal: toolCalls.length,
+      ...stringField("name", name),
+      ...stringField("argumentsText", argumentsText)
+    });
+  });
+  return toolCalls;
+}
+function visit(value, callback) {
+  const stack = [value];
+  const seen = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const current = stack.pop();
+    callback(current);
+    if (Array.isArray(current)) {
+      for (let i = current.length - 1; i >= 0; i--)
+        stack.push(current[i]);
+      continue;
+    }
+    if (typeof current !== "object" || current === null)
+      continue;
+    if (seen.has(current))
+      continue;
+    seen.add(current);
+    const children = Object.values(current);
+    for (let i = children.length - 1; i >= 0; i--)
+      stack.push(children[i]);
+  }
+}
+function looksLikeToolCall(record) {
+  return getString(record, "type") === "tool_call" || getString(record, "type") === "toolCall" || getString(record, "kind") === "tool_call" || getString(record, "toolName") !== void 0 || getString(record, "name") !== void 0;
+}
+function messageRoleDisposition(rawRole) {
+  if (rawRole === void 0)
+    return "project";
+  if (isKernelMessageRole(rawRole))
+    return kernelRoleDisposition(rawRole);
+  return isProjectableMessageRole(rawRole) ? "project" : "project_unknown";
+}
+function normalizeUnknownMessageEvent(event) {
+  const rawRole = getRawMessageRole(event) ?? "unknown";
+  const unknownPart = {
+    type: "unknown_message_role",
+    rawRole,
+    value: event
+  };
+  const message = asRecord2(asRecord2(event)?.["message"]);
+  return {
+    ...event,
+    role: "custom",
+    customType: UNKNOWN_ACTIVITY_CUSTOM_TYPE,
+    details: { rawRole, value: event },
+    content: [unknownPart],
+    ...message === void 0 ? {} : {
+      message: {
+        ...message,
+        role: "custom",
+        customType: UNKNOWN_ACTIVITY_CUSTOM_TYPE,
+        details: { rawRole, value: event },
+        content: [unknownPart]
+      }
+    }
+  };
+}
+function kernelRoleDisposition(role) {
+  switch (role) {
+    case "user":
+    case "assistant":
+      return "project";
+    case "toolResult":
+      return "fold_tool_result";
+    // pi-ai 0.86+ added kernel `system` messages (the composed system prompt
+    // as a transcript message). Bonsai renders the system prompt out-of-band;
+    // projecting it here would duplicate it into the chat surface.
+    case "system":
+      return "drop";
+    default: {
+      const _exhaustive = role;
+      void _exhaustive;
+      return "drop";
+    }
+  }
+}
+var PROJECTABLE_MESSAGE_ROLES = /* @__PURE__ */ new Set([
+  "assistant",
+  "user",
+  "system",
+  "custom"
+]);
+function getRawMessageRole(event) {
+  return getString(event, "role") ?? getStringPath(event, ["message", "role"]) ?? getStringPath(event, ["entry", "role"]);
+}
+function getMessageRole(event) {
+  const role = getRawMessageRole(event);
+  if (role !== void 0 && isProjectableMessageRole(role)) {
+    return role;
+  }
+  return event.type === "message_update" || event.type === "message_end" ? "assistant" : "custom";
+}
+function isProjectableMessageRole(role) {
+  return PROJECTABLE_MESSAGE_ROLES.has(role);
+}
+function getCustomType(event) {
+  return getString(event, "customType") ?? getStringPath(event, ["message", "customType"]) ?? getStringPath(event, ["entry", "customType"]);
+}
+function getMessageDetails(event) {
+  const record = asRecord2(event);
+  const message = asRecord2(record?.["message"]);
+  const entry = asRecord2(record?.["entry"]);
+  return record?.["details"] ?? message?.["details"] ?? entry?.["details"];
+}
+function getMessageDisplay(event) {
+  const record = asRecord2(event);
+  const message = asRecord2(record?.["message"]);
+  const entry = asRecord2(record?.["entry"]);
+  const display = record?.["display"] ?? message?.["display"] ?? entry?.["display"];
+  return typeof display === "boolean" ? display : void 0;
+}
+function toolCallFailureField(value) {
+  const record = asRecord2(value);
+  if (record === void 0)
+    return {};
+  const result = asRecord2(record["result"]);
+  const message = asRecord2(record["message"]);
+  const entry = asRecord2(record["entry"]);
+  const failure = readToolCallFailure(record["details"]) ?? readToolCallFailure(result?.["details"]) ?? readToolCallFailure(message?.["details"]) ?? readToolCallFailure(entry?.["details"]);
+  return failure === void 0 ? {} : { failure };
+}
+function getDeliveredVia(event) {
+  return getStringPath(event, ["message", "deliveredVia"]) ?? getStringPath(event, ["entry", "deliveredVia"]);
+}
+function getPresentationAnchor(event) {
+  const record = asRecord2(event);
+  const message = asRecord2(record?.["message"]);
+  const entry = asRecord2(record?.["entry"]);
+  const candidate = record?.["presentationAnchor"] ?? message?.["presentationAnchor"] ?? entry?.["presentationAnchor"];
+  return parsePresentationAnchor(candidate);
+}
+function presentationAnchorField(anchor) {
+  return anchor === void 0 ? {} : { presentationAnchor: anchor };
+}
+function getMessageId(event) {
+  return getString(event, "messageId") ?? getString(event, "clientIntentId") ?? getStringPath(event, ["message", "clientIntentId"]) ?? getStringPath(event, ["message", "id"]) ?? getStringPath(event, ["entry", "id"]) ?? getString(event, "id");
+}
+function getEntryId(event) {
+  return getString(event, "entryId") ?? getStringPath(event, ["entry", "id"]);
+}
+function getResponseId(event) {
+  return getString(event, "responseId") ?? getStringPath(event, ["message", "responseId"]) ?? getStringPath(event, ["entry", "responseId"]);
+}
+function getProvider(event) {
+  return getString(event, "provider") ?? getStringPath(event, ["message", "provider"]) ?? getStringPath(event, ["entry", "provider"]);
+}
+function getAdapter(event) {
+  return getString(event, "api") ?? getStringPath(event, ["message", "api"]) ?? getStringPath(event, ["entry", "api"]);
+}
+function getModel(event) {
+  return getString(event, "model") ?? getStringPath(event, ["message", "model"]) ?? getStringPath(event, ["entry", "model"]);
+}
+function getTimestamp(value) {
+  const timestamp = getString(value, "timestamp") ?? getStringPath(value, ["message", "timestamp"]) ?? getStringPath(value, ["entry", "timestamp"]);
+  if (timestamp !== void 0)
+    return timestamp;
+  const numeric = getNumber(value, "timestamp");
+  return numeric === void 0 ? void 0 : String(numeric);
+}
+function getToolCallId(value) {
+  const record = asRecord2(value);
+  if (record === void 0)
+    return void 0;
+  return getString(record, "toolCallId") ?? getString(record, "tool_call_id") ?? getStringPath(record, ["toolCall", "id"]) ?? getString(record, "id") ?? getString(record, "toolUseId") ?? getString(record, "tool_use_id") ?? getStringPath(record, ["tool_call", "id"]);
+}
+function getToolName(value) {
+  const record = asRecord2(value);
+  if (record === void 0)
+    return void 0;
+  return getString(record, "toolName") ?? getString(record, "name") ?? getStringPath(record, ["toolCall", "name"]) ?? getStringPath(record, ["tool_call", "name"]) ?? getStringPath(record, ["function", "name"]);
+}
+function getArgumentsText(value) {
+  const record = asRecord2(value);
+  if (record === void 0)
+    return void 0;
+  const candidates = [
+    record.argumentsText,
+    record.arguments,
+    record.args,
+    record.input,
+    getPath(record, ["toolCall", "arguments"]),
+    getPath(record, ["tool_call", "arguments"]),
+    getPath(record, ["function", "arguments"])
+  ];
+  let emptySerialized;
+  for (const candidate of candidates) {
+    let text;
+    if (candidate !== null && typeof candidate === "object") {
+      try {
+        text = JSON.stringify(candidate);
+      } catch {
+      }
+    } else {
+      text = toDisplayText(candidate);
+    }
+    if (text === void 0 || text === "")
+      continue;
+    if (text === "{}" || text === "[]") {
+      emptySerialized ??= text;
+      continue;
+    }
+    return text;
+  }
+  return emptySerialized;
+}
+function getResultText(value) {
+  const record = asRecord2(value);
+  if (record === void 0)
+    return void 0;
+  return firstSerializableText([
+    record.result,
+    record.output,
+    record.content,
+    record.text
+  ]);
+}
+function getErrorText(value) {
+  const record = asRecord2(value);
+  if (record === void 0)
+    return void 0;
+  return firstSerializableText([
+    record.error,
+    record.errorText,
+    record.errorMessage,
+    getPath(record, ["message", "error"]),
+    getPath(record, ["message", "errorText"]),
+    getPath(record, ["message", "errorMessage"]),
+    getPath(record, ["entry", "error"]),
+    getPath(record, ["entry", "errorText"]),
+    getPath(record, ["entry", "errorMessage"])
+  ]);
+}
+function extractText(value) {
+  const record = asRecord2(value);
+  if (typeof value === "string")
+    return value;
+  if (record === void 0)
+    return "";
+  const direct = firstSerializableText([
+    record.text,
+    record.delta,
+    record.content,
+    getPath(record, ["message", "text"]),
+    getPath(record, ["message", "content"]),
+    getPath(record, ["message", "errorMessage"]),
+    getPath(record, ["entry", "text"]),
+    getPath(record, ["entry", "content"]),
+    getPath(record, ["entry", "errorMessage"]),
+    record.errorMessage
+  ]);
+  return direct ?? "";
+}
+function firstSerializableText(values) {
+  for (const value of values) {
+    const text = toDisplayText(value);
+    if (text !== void 0 && text !== "")
+      return text;
+  }
+  return void 0;
+}
+function firstArray(values) {
+  return values.find((value) => Array.isArray(value));
+}
+function toDisplayText(value) {
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    const text = value.map((item) => {
+      const record2 = asRecord2(item);
+      if (record2 !== void 0) {
+        return toDisplayText(record2.text) ?? toDisplayText(record2.content) ?? void 0;
+      }
+      return toDisplayText(item);
+    }).filter((item) => item !== void 0 && item !== "").join("");
+    return text === "" ? void 0 : text;
+  }
+  const record = asRecord2(value);
+  if (record !== void 0) {
+    return toDisplayText(record.text) ?? toDisplayText(record.content) ?? void 0;
+  }
+  return void 0;
+}
+function drivesTheReducedRun(event) {
+  const channel = getString(event, "channel");
+  return channel === void 0 || channel === "prompt";
+}
+function getString(value, key) {
+  const record = asRecord2(value);
+  const field = record?.[key];
+  return typeof field === "string" ? field : void 0;
+}
+function getNumber(value, key) {
+  const record = asRecord2(value);
+  const field = record?.[key];
+  return typeof field === "number" ? field : void 0;
+}
+function getArray(value, key) {
+  const record = asRecord2(value);
+  const field = record?.[key];
+  return Array.isArray(field) ? field : void 0;
+}
+function getStringPath(value, path) {
+  const found = getPath(value, path);
+  return typeof found === "string" ? found : void 0;
+}
+function getPath(value, path) {
+  let current = value;
+  for (const key of path) {
+    const record = asRecord2(current);
+    if (record === void 0)
+      return void 0;
+    current = record[key];
+  }
+  return current;
+}
+function asRecord2(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function omitKey(record, key) {
+  const { [key]: _omitted, ...rest } = record;
+  void _omitted;
+  return rest;
+}
+
+// packages/herd-transcript/dist/interactive/custom-message-placement.js
+var OTHER_CUSTOM_TYPES = "*";
+function customMessagePlacement(row, details, display) {
+  if (row === void 0)
+    return display === false ? "outside-transcript" : "standalone";
+  return typeof row.placement === "function" ? row.placement(details, display) : row.placement;
+}
+var DEFAULT_ROWS = [
+  // The projection fills a user turn's attachments, dynamic context, invoked command and paste
+  // slots from these.
+  ...[
+    ATTACHMENTS_CUSTOM_TYPE,
+    DYNAMIC_CONTEXT_CUSTOM_TYPE,
+    USER_INVOKED_CUSTOM_TYPE,
+    USER_PASTED_CONTENT_CUSTOM_TYPE
+  ].map((typeKey) => ({ typeKey, placement: "companion-of-send" })),
+  // A card answer: the person's input, sent with no text of its own.
+  { typeKey: UI_ACTION_CUSTOM_TYPE, placement: "opens-turn" },
+  // Maintenance the run already performed, not an input the agent resumes on.
+  { typeKey: COMPACTION_MARKER_CUSTOM_TYPE, placement: "standalone" },
+  {
+    typeKey: FINAL_OUTPUT_REPAIR_CUSTOM_TYPE,
+    placement: "continues-agent-turn"
+  },
+  // A spawn can keep its result out of the person's transcript (`display: false`).
+  {
+    typeKey: SUBAGENT_RESULT_CUSTOM_TYPE,
+    placement: (details, display) => display === false ? "outside-transcript" : isSubagentResultDetails(details) ? "continues-agent-turn" : "standalone"
+  },
+  {
+    typeKey: BACKGROUND_TASK_RESULT_CUSTOM_TYPE,
+    placement: (details) => isBackgroundTaskResultDetails(details) ? "continues-agent-turn" : "standalone"
+  },
+  {
+    typeKey: DAEMON_SERVICE_TURN_CUSTOM_TYPE,
+    placement: (details) => isDaemonWakeDetails(details) ? "continues-agent-turn" : "standalone"
+  },
+  // The kernel's notes to the model about a compaction it ran mid-turn and a run it continued.
+  {
+    typeKey: MID_TURN_COMPACTION_OUTCOME_CUSTOM_TYPE,
+    placement: "outside-transcript"
+  },
+  {
+    typeKey: RUN_CONTINUATION_CARRIER_CUSTOM_TYPE,
+    placement: "outside-transcript"
+  }
+];
+var DEFAULT_CUSTOM_MESSAGE_PLACEMENTS = new Map(DEFAULT_ROWS.map((row) => [row.typeKey, row]));
+function placementOfCustomMessage(item, placements) {
+  const row = (item.customType === void 0 ? void 0 : placements.get(item.customType) ?? DEFAULT_CUSTOM_MESSAGE_PLACEMENTS.get(item.customType)) ?? placements.get(OTHER_CUSTOM_TYPES);
+  return customMessagePlacement(row, item.details, item.display);
+}
+function isEmbeddedAgentContinuationMessage(item, placements) {
+  return item.role === "custom" && item.status === "complete" && item.customType !== void 0 && placementOfCustomMessage(item, placements) === "continues-agent-turn";
+}
+
+// packages/herd-transcript/dist/interactive/canonical-run-boundaries.js
+function boundaryAnchorKey(anchor) {
+  return `${anchor.type}:${anchor.id}`;
+}
+function hasTerminalFinalOutputInRange(items, from, to) {
+  for (let scan = from; scan < to; scan += 1) {
+    if (isTerminalFinalOutput(items, scan))
+      return true;
+  }
+  return false;
+}
+function isBoundaryCausalItem(item) {
+  return item.type === "tool" || item.role === "assistant" || item.role === "user";
+}
+function markAnchor(index, anchor, rank) {
+  index.keys.add(boundaryAnchorKey(anchor));
+  let byId = index.firstRankByTypeAndId.get(anchor.type);
+  if (byId === void 0) {
+    byId = /* @__PURE__ */ new Map();
+    index.firstRankByTypeAndId.set(anchor.type, byId);
+  }
+  const first = byId.get(anchor.id);
+  if (first === void 0 || rank < first)
+    byId.set(anchor.id, rank);
+}
+function buildAnchorIndex(anchors) {
+  const index = {
+    keys: /* @__PURE__ */ new Set(),
+    firstRankByTypeAndId: /* @__PURE__ */ new Map()
+  };
+  anchors.forEach((anchor, rank) => markAnchor(index, anchor, rank));
+  return index;
+}
+function indexCompletedRunBoundaryAnchorsOverKeptItems(anchors, all, kept) {
+  if (anchors === void 0)
+    return void 0;
+  const index = buildAnchorIndex(anchors);
+  if (kept === all)
+    return index;
+  let next = 0;
+  let previous;
+  for (const item of all) {
+    if (kept[next] === item) {
+      next += 1;
+      previous = item;
+      continue;
+    }
+    if (previous === void 0)
+      continue;
+    const rank = index.firstRankByTypeAndId.get(item.type)?.get(item.id);
+    if (rank !== void 0)
+      markAnchor(index, previous, rank);
+  }
+  return index;
+}
+function completedBoundaryIndices(items, anchorIndex) {
+  if (anchorIndex === void 0)
+    return [];
+  const found = [];
+  for (let index = 0; index < items.length; index += 1) {
+    const item = items[index];
+    const rank = anchorIndex.firstRankByTypeAndId.get(item.type)?.get(item.id);
+    if (rank !== void 0)
+      found.push({ rank, index });
+  }
+  if (found.length > 1)
+    found.sort((a, b) => a.rank - b.rank);
+  const indices = [];
+  let previousRank = -1;
+  let previousIndex = -1;
+  for (const { rank, index } of found) {
+    if (rank === previousRank)
+      continue;
+    previousRank = rank;
+    if (index <= previousIndex)
+      continue;
+    indices.push(index);
+    previousIndex = index;
+  }
+  return indices;
+}
+function finalProseKeysAtCompletedBoundaries(items, anchorIndex) {
+  const keys = /* @__PURE__ */ new Set();
+  let previousBoundaryIndex = -1;
+  for (const boundaryIndex of completedBoundaryIndices(items, anchorIndex)) {
+    for (let index = boundaryIndex; index > previousBoundaryIndex; index -= 1) {
+      const candidate = items[index];
+      if (candidate?.type !== "tool" || candidate.status !== "complete" || candidate.name !== RESERVED_FINAL_OUTPUT_TOOL_NAME)
+        continue;
+      const capture = finalOutputCaptureFromDetails(candidate.toolCallId, candidate.resultDetails);
+      if (capture === void 0 || capture.terminatesRun !== void 0 || capture.message !== void 0)
+        continue;
+      const waveId = canonicalToolWaveId(candidate);
+      let hasLaterCausalItem = false;
+      for (let scan = index + 1; scan <= boundaryIndex; scan += 1) {
+        const later = items[scan];
+        if (later === void 0 || !isBoundaryCausalItem(later))
+          continue;
+        if (later.type === "tool" && canonicalToolWaveId(later) === waveId)
+          continue;
+        hasLaterCausalItem = true;
+        break;
+      }
+      if (hasLaterCausalItem)
+        continue;
+      if (candidate.sourceMessageId !== void 0)
+        keys.add(candidate.sourceMessageId);
+      if (candidate.responseId !== void 0)
+        keys.add(candidate.responseId);
+      break;
+    }
+    previousBoundaryIndex = boundaryIndex;
+  }
+  return keys;
+}
+function canonicalToolWaveId(tool) {
+  return tool.waveId ?? canonicalId("tool-wave", tool.responseId ?? tool.sourceMessageId ?? tool.id);
+}
+function finalOutputTerminatesRun(capture) {
+  return capture.terminatesRun === true || capture.terminatesRun === void 0 && capture.message !== void 0;
+}
+function isTerminalFinalOutput(items, index) {
+  const item = items[index];
+  if (item?.type !== "tool" || item.status !== "complete" || item.name !== RESERVED_FINAL_OUTPUT_TOOL_NAME) {
+    return false;
+  }
+  const capture = finalOutputCaptureFromDetails(item.toolCallId, item.resultDetails);
+  return capture !== void 0 && finalOutputTerminatesRun(capture);
+}
+function hasTerminalFinalOutput(items) {
+  return items.some((_, index) => isTerminalFinalOutput(items, index));
+}
+function hasExhaustedRequiredFinalOutputRepair(items) {
+  const repairIndex = items.findIndex((item) => item.type === "message" && isRequiredFinalOutputRepairMessage(item));
+  if (repairIndex === -1)
+    return false;
+  return items.slice(repairIndex + 1).some((item) => item.type === "message" && item.role === "assistant" && item.status === "complete" && item.finishReason === "complete");
+}
+function continuationFollowsLastAssistant(items, placements) {
+  const lastAssistantIndex = items.findLastIndex((item) => item.type === "message" && item.role === "assistant");
+  return items.slice(lastAssistantIndex + 1).some((item) => item.type === "message" && isEmbeddedAgentContinuationMessage(item, placements));
+}
+function hasTrailingAwaitableResult(items) {
+  const last = items.at(-1);
+  return last !== void 0 && last.type === "message" && isEmbeddedAgentResultMessage(last);
+}
+function hasPendingBackgroundWork(items, state) {
+  return items.some((item) => item.type === "tool" && item.backgroundTaskId !== void 0 && state.backgroundTasksById[item.backgroundTaskId]?.status === "running");
+}
+function canonicalId(kind, sourceId) {
+  return `${kind}:${encodeURIComponent(sourceId)}`;
+}
+
+// packages/herd-transcript/dist/interactive/canonical-attempt-lifecycle.js
+function attemptLifecycleStatus(attempt) {
+  if (attempt.detached === true && (attempt.status === "running" || attempt.status === "pending")) {
+    return "succeeded";
+  }
+  return attempt.status;
+}
+
+// packages/herd-transcript/dist/interactive/canonical-recovery.js
+function failureOwner(block) {
+  if (block.kind === "provisional_response" || block.kind === "final_answer")
+    return block.status === "failed" ? block.sourceMessageId : void 0;
+  if (block.kind === "custom_message")
+    return block.message.failure === void 0 ? void 0 : block.message.id;
+  return void 0;
+}
+function isReply(block) {
+  return block.kind === "provisional_response" || block.kind === "final_answer";
+}
+function failedSources(blocks) {
+  const sources = /* @__PURE__ */ new Set();
+  for (const block of blocks) {
+    if ((block.kind === "narration" || block.kind === "provisional_response" || block.kind === "final_answer") && block.status === "failed")
+      sources.add(block.sourceMessageId);
+  }
+  return sources;
+}
+function isSettled(attempt) {
+  const status = attemptLifecycleStatus(attempt);
+  return status === "succeeded" || status === "failed";
+}
+function attemptsOf(block) {
+  if (block.kind === "work_episode")
+    return block.waves.flatMap((wave) => wave.attempts);
+  return block.kind === "tool_surface" ? [block.attempt] : [];
+}
+function isTextProgress(block) {
+  return (block.kind === "narration" || block.kind === "provisional_response" || block.kind === "final_answer") && block.status === "succeeded" && block.text.trim() !== "";
+}
+function showsProgress(blocks, failed) {
+  return blocks.some((block) => isTextProgress(block) || attemptsOf(block).some((attempt) => isSettled(attempt) && (attempt.sourceMessageId === void 0 ? failed.size === 0 : !failed.has(attempt.sourceMessageId))));
+}
+function stretchFlags(blocks, from, to, status, recoveredAnyway, flags) {
+  const stretch = blocks.slice(from, to);
+  const failed = failedSources(stretch);
+  let textFollows = false;
+  const askers = [];
+  const recovered = /* @__PURE__ */ new Map();
+  for (let index = to - 1; index >= from; index -= 1) {
+    const block = blocks[index];
+    const owner = failureOwner(block);
+    if (owner !== void 0) {
+      recovered.set(index, recoveredAnyway || textFollows || askers.some((asker) => asker !== owner));
+    }
+    if (isTextProgress(block))
+      textFollows = true;
+    for (const attempt of attemptsOf(block)) {
+      const asker = attempt.sourceMessageId;
+      if (asker === void 0 || !isSettled(attempt) || failed.has(asker) || askers.includes(asker) || askers.length === 2)
+        continue;
+      askers.push(asker);
+    }
+  }
+  let lastReply = -1;
+  for (let index = to - 1; index >= from; index -= 1) {
+    if (isReply(blocks[index])) {
+      lastReply = index;
+      break;
+    }
+  }
+  for (const [index, isRecovered] of recovered) {
+    flags.set(index, {
+      recovered: isRecovered,
+      terminal: index === lastReply && status === "failed" && blocks[index].kind !== "custom_message" && !isRecovered
+    });
+  }
+}
+function isPending(status) {
+  return status === "running" || status === "pending";
+}
+function withFlags(turn, laterTurnProgress) {
+  const { blocks } = turn;
+  if (!blocks.some((block) => failureOwner(block) !== void 0))
+    return turn;
+  const flags = /* @__PURE__ */ new Map();
+  const prefix = turn.settledBlockCount ?? 0;
+  if (isPending(turn.status) && prefix > 0) {
+    const continuation = blocks.slice(prefix);
+    stretchFlags(blocks, 0, prefix, turn.settledStatus ?? "succeeded", laterTurnProgress || showsProgress(continuation, failedSources(blocks)), flags);
+    stretchFlags(blocks, prefix, blocks.length, turn.status, laterTurnProgress, flags);
+  } else {
+    stretchFlags(blocks, 0, blocks.length, turn.status, laterTurnProgress, flags);
+  }
+  let changed = false;
+  const flagged = blocks.map((block, index) => {
+    const flag = flags.get(index);
+    if (flag === void 0 || !flag.recovered && !flag.terminal)
+      return block;
+    changed = true;
+    return {
+      ...block,
+      ...flag.recovered ? { recovered: true } : {},
+      ...flag.terminal ? { terminal: true } : {}
+    };
+  });
+  return changed ? { ...turn, blocks: flagged } : turn;
+}
+function withRecoveryFlags(turns) {
+  let laterTurnProgress = false;
+  let result;
+  for (let index = turns.length - 1; index >= 0; index -= 1) {
+    const turn = turns[index];
+    if (turn.kind !== "agent")
+      continue;
+    const flagged = withFlags(turn, laterTurnProgress);
+    if (flagged !== turn) {
+      result ??= [...turns];
+      result[index] = flagged;
+    }
+    laterTurnProgress ||= showsProgress(turn.blocks, failedSources(turn.blocks));
+  }
+  return result ?? turns;
+}
+
+// packages/herd-transcript/dist/interactive/canonical-transcript.js
+var UNKNOWN_ACTIVITY_CUSTOM_TYPE2 = "herd.unknown_activity";
+function isSteerContinuation(items, index, completedRunBoundaryItemIds) {
+  const item = items[index];
+  const stamped = item?.type === "message" ? item.deliveredVia : void 0;
+  if (stamped === "steer")
+    return true;
+  if (stamped === "prompt" || stamped === "next_turn")
+    return false;
+  let lastAssistantIndex = -1;
+  for (let scan = index - 1; scan >= 0; scan -= 1) {
+    const candidate = items[scan];
+    if (candidate?.type === "message" && candidate.role === "assistant") {
+      lastAssistantIndex = scan;
+      break;
+    }
+  }
+  if (lastAssistantIndex === -1)
+    return false;
+  const lastAssistant = items[lastAssistantIndex];
+  if (completedRunBoundaryItemIds !== void 0) {
+    for (let scan = lastAssistantIndex; scan < index; scan += 1) {
+      const candidate = items[scan];
+      if (candidate !== void 0 && completedRunBoundaryItemIds.has(boundaryAnchorKey(candidate)))
+        return false;
+    }
+  }
+  if (lastAssistant.runAborted)
+    return false;
+  if (lastAssistant.status === "streaming")
+    return true;
+  if (lastAssistant.finishReason === "tool_use") {
+    if (hasTerminalFinalOutputInRange(items, lastAssistantIndex, index)) {
+      return false;
+    }
+    if (hasInterruptedWorkInRange(items, lastAssistantIndex, index)) {
+      return false;
+    }
+    return true;
+  }
+  if (lastAssistant.finishReason !== void 0)
+    return false;
+  for (let scan = 0; scan < index; scan += 1) {
+    const candidate = items[scan];
+    if (candidate?.type === "tool" && candidate.backgroundTaskId === void 0 && (candidate.status === "running" || candidate.status === "declared" || candidate.status === "arguments_complete")) {
+      return true;
+    }
+  }
+  return false;
+}
+function hasInterruptedWorkInRange(items, from, to) {
+  for (let scan = from; scan < to; scan += 1) {
+    const item = items[scan];
+    if (item?.type === "tool" && item.backgroundTaskId === void 0 && (item.status === "interrupted" || item.status === "cancelled")) {
+      return true;
+    }
+  }
+  return false;
+}
+function companionIntentId(item) {
+  const details = item.details;
+  if (details === null || typeof details !== "object")
+    return void 0;
+  const value = details["clientIntentId"];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function indexUserMessages(items) {
+  let indexById;
+  return (id) => {
+    if (indexById === void 0) {
+      indexById = /* @__PURE__ */ new Map();
+      for (const [index, item] of items.entries()) {
+        if (item.type === "message" && item.role === "user" && !indexById.has(item.id))
+          indexById.set(item.id, index);
+      }
+    }
+    return indexById.get(id) ?? -1;
+  };
+}
+function isSendCompanion(item, placements) {
+  return item.role === "custom" && placementOfCustomMessage(item, placements) === "companion-of-send";
+}
+function companionOwnerIndex(items, index, completedRunBoundaryItemIds, userMessageIndexOf, placements) {
+  const item = items[index];
+  if (item?.type !== "message")
+    return void 0;
+  const intentId = companionIntentId(item);
+  if (intentId !== void 0) {
+    const owner = userMessageIndexOf(intentId);
+    return owner < 0 ? void 0 : owner;
+  }
+  const neighbors = [];
+  for (const step of [1, -1]) {
+    for (let scan = index + step; scan >= 0 && scan < items.length; scan += step) {
+      const candidate = items[scan];
+      if (candidate?.type === "message" && (candidate.role === "system" || isSendCompanion(candidate, placements)))
+        continue;
+      if (candidate?.type === "message" && candidate.role === "user")
+        neighbors.push(scan);
+      break;
+    }
+  }
+  return neighbors.find((neighbor) => isSteerContinuation(items, neighbor, completedRunBoundaryItemIds)) ?? neighbors[0];
+}
+var attachmentOnlyUsers = /* @__PURE__ */ new WeakMap();
+function attachmentOnlyUser(item) {
+  const cached = attachmentOnlyUsers.get(item);
+  if (cached !== void 0)
+    return cached;
+  const user = {
+    id: item.id,
+    type: "message",
+    role: "user",
+    status: item.status,
+    text: "",
+    parts: [],
+    ...item.entryId === void 0 ? {} : { entryId: item.entryId },
+    ...item.startedAt === void 0 ? {} : { startedAt: item.startedAt },
+    ...item.completedAt === void 0 ? {} : { completedAt: item.completedAt }
+  };
+  attachmentOnlyUsers.set(item, user);
+  return user;
+}
+function isCardAnswerInput(items, index, placements, completedRunBoundaryItemIds) {
+  const item = items[index];
+  if (item?.type !== "message" || item.role !== "custom" || placementOfCustomMessage(item, placements) !== "opens-turn")
+    return false;
+  return !isSteerContinuation(items, index, completedRunBoundaryItemIds);
+}
+function attachmentOnlyInput(items, index, completedRunBoundaryItemIds, userMessageIndexOf, placements) {
+  const item = items[index];
+  if (item?.type !== "message" || item.role !== "custom" || item.customType !== ATTACHMENTS_CUSTOM_TYPE)
+    return false;
+  const details = item.details;
+  return Array.isArray(details?.refs) && details.refs.length > 0 && companionOwnerIndex(items, index, completedRunBoundaryItemIds, userMessageIndexOf, placements) === void 0;
+}
+function freshPromptCompanions(items, completedRunBoundaryItemIds, userMessageIndexOf, placements) {
+  const byUser = /* @__PURE__ */ new Map();
+  items.forEach((item, index) => {
+    if (item.type === "message" && item.role === "user" && !isSteerContinuation(items, index, completedRunBoundaryItemIds))
+      byUser.set(item.id, {});
+  });
+  const consumed = /* @__PURE__ */ new Set();
+  items.forEach((item, index) => {
+    if (item.type !== "message" || item.role !== "custom")
+      return;
+    const slot = item.customType === ATTACHMENTS_CUSTOM_TYPE ? "attachments" : item.customType === DYNAMIC_CONTEXT_CUSTOM_TYPE ? "dynamicContext" : item.customType === USER_INVOKED_CUSTOM_TYPE ? "invoked" : item.customType === USER_PASTED_CONTENT_CUSTOM_TYPE ? "pastedContent" : void 0;
+    if (slot === void 0)
+      return;
+    const ownerIndex = companionOwnerIndex(items, index, completedRunBoundaryItemIds, userMessageIndexOf, placements);
+    const owner = ownerIndex === void 0 ? void 0 : items[ownerIndex]?.id;
+    const paired = owner === void 0 ? void 0 : byUser.get(owner);
+    if (owner !== void 0 && paired !== void 0 && paired[slot] === void 0) {
+      byUser.set(owner, { ...paired, [slot]: item });
+      consumed.add(item.id);
+    }
+  });
+  return { byUser, consumed };
+}
+function projectCanonicalTranscript(state, placements) {
+  const outside = (item) => isOutsideTranscript(item, placements);
+  const items = dropRepeatedDeliveries(state.items.some(outside) ? state.items.filter((item) => !outside(item)) : state.items);
+  const projectedState = items === state.items ? state : { ...state, items };
+  const anchorIndex = indexCompletedRunBoundaryAnchorsOverKeptItems(state.completedRunBoundaryAnchors, state.items, items);
+  const completedRunBoundaryItemIds = anchorIndex?.keys;
+  const userMessageIndexOf = indexUserMessages(items);
+  const promptCompanions = freshPromptCompanions(items, completedRunBoundaryItemIds, userMessageIndexOf, placements);
+  const turns = [];
+  const segments = [];
+  let agentItems = [];
+  let causedByUserMessageId;
+  let causeItem;
+  const flushAgent = () => {
+    if (agentItems[0] === void 0)
+      return false;
+    segments.push({
+      slot: turns.length,
+      items: agentItems,
+      causedByUserMessageId,
+      causeItem
+    });
+    turns.push(void 0);
+    agentItems = [];
+    return true;
+  };
+  for (const [index, item] of items.entries()) {
+    if (item.type === "message" && item.role === "system")
+      continue;
+    if (item.type === "message" && item.role === "user") {
+      if (isSteerContinuation(items, index, completedRunBoundaryItemIds)) {
+        agentItems.push(item);
+        if (causedByUserMessageId === void 0) {
+          causedByUserMessageId = item.id;
+          causeItem = item;
+        }
+        continue;
+      }
+      flushAgent();
+      turns.push({
+        kind: "user",
+        id: canonicalId("user-turn", item.id),
+        sourceMessageId: item.id,
+        text: item.text,
+        message: item,
+        ...promptCompanions.byUser.get(item.id)
+      });
+      causedByUserMessageId = item.id;
+      causeItem = item;
+      continue;
+    }
+    if (attachmentOnlyInput(items, index, completedRunBoundaryItemIds, userMessageIndexOf, placements) && item.type === "message") {
+      const user = attachmentOnlyUser(item);
+      flushAgent();
+      turns.push({
+        kind: "user",
+        id: canonicalId("user-turn", user.id),
+        sourceMessageId: user.id,
+        text: "",
+        message: user,
+        attachments: item
+      });
+      causedByUserMessageId = user.id;
+      causeItem = user;
+      continue;
+    }
+    if (isCardAnswerInput(items, index, placements, completedRunBoundaryItemIds) && item.type === "message") {
+      flushAgent();
+      turns.push({
+        kind: "custom",
+        id: canonicalId("card-answer", item.id),
+        sourceMessageId: item.id,
+        message: item
+      });
+      causedByUserMessageId = item.id;
+      causeItem = item;
+      continue;
+    }
+    if (promptCompanions.consumed.has(item.id))
+      continue;
+    agentItems.push(item);
+  }
+  flushAgent();
+  const latestSegment = segments[segments.length - 1];
+  const transcriptEndsWithAgentSegment = turns[turns.length - 1] === void 0;
+  for (const segment of segments) {
+    turns[segment.slot] = projectAgentTurn(segment.items, segment.causedByUserMessageId, segment.causeItem, transcriptEndsWithAgentSegment && segment === latestSegment, projectedState, anchorIndex, placements);
+  }
+  return {
+    turns: withRecoveryFlags(turns.filter((turn) => turn !== void 0))
+  };
+}
+function dropRepeatedDeliveries(items) {
+  const seen = /* @__PURE__ */ new Set();
+  let dropped = false;
+  const kept = items.filter((item) => {
+    if (item.type !== "message" || item.role !== "custom")
+      return true;
+    const details = item.details;
+    if (details === null || typeof details !== "object")
+      return true;
+    const deliveryId = details["deliveryId"];
+    if (typeof deliveryId !== "string" || deliveryId.length === 0)
+      return true;
+    const key = `${item.customType ?? ""}\0${deliveryId}`;
+    if (seen.has(key)) {
+      dropped = true;
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+  return dropped ? kept : items;
+}
+function isOutsideTranscript(item, placements) {
+  return item.type === "message" && item.role === "custom" && placementOfCustomMessage(item, placements) === "outside-transcript";
+}
+function projectAgentTurn(items, causedByUserMessageId, causeItem, isLatestTurn, state, anchorIndex, placements) {
+  const first = items[0];
+  if (first === void 0) {
+    throw new Error("Cannot project an empty agent turn");
+  }
+  const turnId = canonicalId("agent-turn", causedByUserMessageId ?? canonicalSourceId(first));
+  const responseSequence = /* @__PURE__ */ new Map();
+  const thinking = [];
+  let nextResponseSequence = 1;
+  let nextStreamStage = 0;
+  const allocateStreamStage = () => nextStreamStage++;
+  const hasRequiredFinalOutputRepair = items.some((item) => item.type === "message" && isRequiredFinalOutputRepairMessage(item));
+  const boundaryFinalProseMessageKeys = finalProseKeysAtCompletedBoundaries(items, anchorIndex);
+  const finalProseMessageKeys = /* @__PURE__ */ new Set([
+    ...boundaryFinalProseMessageKeys,
+    ...items.flatMap((item, itemIndex) => {
+      if (item.type !== "tool" || item.status !== "complete" || item.name !== RESERVED_FINAL_OUTPUT_TOOL_NAME) {
+        return [];
+      }
+      const capture = finalOutputCaptureFromDetails(item.toolCallId, item.resultDetails);
+      if (capture === void 0 || capture.message !== void 0 || !isTerminalFinalOutput(items, itemIndex))
+        return [];
+      return [item.sourceMessageId, item.responseId].filter((key) => key !== void 0);
+    })
+  ]);
+  for (const item of items) {
+    if (item.type !== "message" || item.role !== "assistant")
+      continue;
+    responseSequence.set(item.id, nextResponseSequence++);
+    thinking.push(...thinkingAnnotations(item));
+  }
+  const blocks = [];
+  const settledItemCount = isLatestTurn ? completedPrefixItemCount(items, anchorIndex?.keys) : 0;
+  let settledBlockCount = 0;
+  let waveBuffer = [];
+  let episodeWaves = [];
+  let episodeHasThinking = false;
+  let episodeStatuses = [];
+  let episodeIdentity;
+  const registerThinkingActivity = (annotations, status2) => {
+    if (annotations.length === 0)
+      return;
+    episodeIdentity ??= annotations[0]?.responseId;
+    episodeHasThinking = true;
+    episodeStatuses.push(status2);
+  };
+  const flushEpisode = () => {
+    if (episodeWaves.length === 0 && !episodeHasThinking)
+      return;
+    const firstWave = episodeWaves[0];
+    const sourceId = episodeIdentity ?? firstWave?.responseId ?? firstWave?.sourceMessageId ?? firstWave?.id ?? turnId;
+    blocks.push({
+      kind: "work_episode",
+      id: canonicalId("work-episode", sourceId),
+      status: aggregateStatus(episodeStatuses),
+      waves: episodeWaves
+    });
+    episodeWaves = [];
+    episodeHasThinking = false;
+    episodeStatuses = [];
+    episodeIdentity = void 0;
+  };
+  const flushWave = () => {
+    const firstAttempt = waveBuffer[0];
+    if (firstAttempt === void 0)
+      return;
+    const wave = projectWave(canonicalToolWaveId(firstAttempt), waveBuffer, responseSequence);
+    episodeIdentity ??= wave.responseId ?? wave.sourceMessageId ?? firstAttempt.responseId;
+    episodeWaves.push(wave);
+    episodeStatuses.push(wave.status);
+    waveBuffer = [];
+  };
+  const pendingAttachments = [];
+  const pendingDynamicContext = [];
+  for (let itemIndex = 0; itemIndex < items.length; itemIndex += 1) {
+    const item = items[itemIndex];
+    if (item === void 0)
+      continue;
+    if (itemIndex === settledItemCount) {
+      flushWave();
+      flushEpisode();
+      settledBlockCount = blocks.length;
+    }
+    if (item.type === "tool") {
+      if (waveBuffer.length > 0 && waveBuffer[0] !== void 0 && canonicalToolWaveId(waveBuffer[0]) !== canonicalToolWaveId(item)) {
+        flushWave();
+      }
+      waveBuffer.push(item);
+      continue;
+    }
+    flushWave();
+    if (item.role === "user") {
+      flushEpisode();
+      let claimedIndex = pendingAttachments.findIndex((pending2) => pending2.intentId === item.id);
+      if (claimedIndex === -1) {
+        claimedIndex = pendingAttachments.findIndex((pending2) => pending2.intentId === void 0);
+      }
+      const claimed = claimedIndex === -1 ? void 0 : pendingAttachments.splice(claimedIndex, 1)[0];
+      let claimedDynamicContextIndex = pendingDynamicContext.findIndex((pending2) => pending2.intentId === item.id);
+      if (claimedDynamicContextIndex === -1) {
+        claimedDynamicContextIndex = pendingDynamicContext.findIndex((pending2) => pending2.intentId === void 0);
+      }
+      const claimedDynamicContext = claimedDynamicContextIndex === -1 ? void 0 : pendingDynamicContext.splice(claimedDynamicContextIndex, 1)[0];
+      blocks.push({
+        kind: "steer_message",
+        id: canonicalId("steer-message", item.id),
+        sourceMessageId: item.id,
+        message: item,
+        ...claimed === void 0 ? {} : { attachments: claimed.item },
+        ...claimedDynamicContext === void 0 ? {} : { dynamicContext: claimedDynamicContext.item }
+      });
+      continue;
+    }
+    if (item.role === "assistant") {
+      const annotations = thinkingAnnotations(item);
+      const response = responseBlocks(item, responseSequence.get(item.id) ?? nextResponseSequence++, allocateStreamStage, hasRequiredFinalOutputRepair, finalProseMessageKeys.has(item.id) || item.responseId !== void 0 && finalProseMessageKeys.has(item.responseId));
+      const narration = response.filter((block) => block.kind === "narration");
+      const following = response.filter((block) => block.kind !== "narration");
+      if (narration.length > 0) {
+        flushEpisode();
+        blocks.push(...narration);
+        registerThinkingActivity(annotations, messageStatus(item));
+        blocks.push(...following);
+        continue;
+      }
+      registerThinkingActivity(annotations, messageStatus(item));
+      if (following.length > 0) {
+        flushEpisode();
+        blocks.push(...following);
+      }
+      continue;
+    }
+    if (isRequiredFinalOutputRepairMessage(item))
+      continue;
+    if (item.role === "custom" && item.customType === DYNAMIC_CONTEXT_CUSTOM_TYPE) {
+      const intentId = companionIntentId(item);
+      if (intentId !== void 0) {
+        const owner = blocks.findLast((block) => block.kind === "steer_message" && block.sourceMessageId === intentId);
+        if (owner !== void 0 && owner.kind === "steer_message") {
+          if (owner.dynamicContext === void 0) {
+            const ownerIndex = blocks.lastIndexOf(owner);
+            blocks[ownerIndex] = { ...owner, dynamicContext: item };
+            continue;
+          }
+        } else if (userItemIndexAfterById(items, itemIndex, intentId) >= 0) {
+          pendingDynamicContext.push({ item, intentId });
+          continue;
+        }
+      } else {
+        const last = blocks[blocks.length - 1];
+        if (last?.kind === "steer_message" && last.dynamicContext === void 0) {
+          blocks[blocks.length - 1] = { ...last, dynamicContext: item };
+          continue;
+        }
+        if (hasUserItemAfter(items, itemIndex) && !pendingDynamicContext.some((pending2) => pending2.intentId === void 0)) {
+          pendingDynamicContext.push({ item, intentId: void 0 });
+          continue;
+        }
+      }
+    }
+    if (item.role === "custom" && item.customType === ATTACHMENTS_CUSTOM_TYPE) {
+      const intentId = companionIntentId(item);
+      if (intentId !== void 0) {
+        const owner = blocks.findLast((block) => block.kind === "steer_message" && block.sourceMessageId === intentId);
+        if (owner !== void 0 && owner.kind === "steer_message") {
+          if (owner.attachments === void 0) {
+            const ownerIndex = blocks.lastIndexOf(owner);
+            blocks[ownerIndex] = { ...owner, attachments: item };
+            continue;
+          }
+        } else if (userItemIndexAfterById(items, itemIndex, intentId) >= 0) {
+          pendingAttachments.push({ item, intentId });
+          continue;
+        }
+      } else if (hasUserItemAfter(items, itemIndex)) {
+        if (!pendingAttachments.some((pending2) => pending2.intentId === void 0)) {
+          pendingAttachments.push({ item, intentId: void 0 });
+          continue;
+        }
+      } else {
+        const last = blocks[blocks.length - 1];
+        if (last?.kind === "steer_message" && last.attachments === void 0) {
+          blocks[blocks.length - 1] = { ...last, attachments: item };
+          continue;
+        }
+      }
+    }
+    if (item.role === "custom" && item.customType !== UNKNOWN_ACTIVITY_CUSTOM_TYPE2) {
+      flushEpisode();
+      blocks.push({
+        kind: "custom_message",
+        id: canonicalId("custom-message", item.id),
+        sourceMessageId: item.id,
+        message: item
+      });
+      continue;
+    }
+    if (!(item.role === "custom" && item.customType === UNKNOWN_ACTIVITY_CUSTOM_TYPE2)) {
+      continue;
+    }
+    flushEpisode();
+    const sequence = responseSequence.get(item.id) ?? nextResponseSequence++;
+    blocks.push(...responseBlocks(item, sequence, allocateStreamStage));
+  }
+  flushWave();
+  flushEpisode();
+  for (const pending2 of pendingAttachments) {
+    blocks.push({
+      kind: "custom_message",
+      id: canonicalId("custom-message", pending2.item.id),
+      sourceMessageId: pending2.item.id,
+      message: pending2.item
+    });
+  }
+  for (const pending2 of pendingDynamicContext) {
+    blocks.push({
+      kind: "custom_message",
+      id: canonicalId("custom-message", pending2.item.id),
+      sourceMessageId: pending2.item.id,
+      message: pending2.item
+    });
+  }
+  const span = turnSpan(causeItem === void 0 ? items : [causeItem, ...items]);
+  const status = agentTurnStatus(blocks, items, state, isLatestTurn, placements);
+  if (settledItemCount === items.length)
+    settledBlockCount = blocks.length;
+  const pending = isLatestTurn && (status === "running" || status === "pending");
+  const hasUnfinishedPrefix = pending && blocks.slice(0, settledBlockCount).some((block) => {
+    const blockStatus = "status" in block ? block.status : "succeeded";
+    return blockStatus === "running" || blockStatus === "pending";
+  });
+  if (hasUnfinishedPrefix)
+    settledBlockCount = 0;
+  const settledItems = pending && settledBlockCount > 0 ? items.slice(0, settledItemCount) : [];
+  const settledStatus = settledItems.length === 0 ? void 0 : agentTurnStatus(blocks.slice(0, settledBlockCount), settledItems, state, false, placements);
+  const settledCompletedAt = turnSpan(settledItems).completedAt;
+  return {
+    kind: "agent",
+    id: turnId,
+    ...causedByUserMessageId === void 0 ? {} : { causedByUserMessageId },
+    status,
+    ...pending ? { settledBlockCount } : {},
+    ...settledStatus === void 0 ? {} : { settledStatus },
+    ...settledCompletedAt === void 0 ? {} : { settledCompletedAt },
+    thinking,
+    blocks,
+    ...span.startedAt === void 0 ? {} : { startedAt: span.startedAt },
+    ...span.completedAt === void 0 ? {} : { completedAt: span.completedAt }
+  };
+}
+function turnSpan(items) {
+  let startedAt;
+  let startedAtMs = Infinity;
+  let completedAt;
+  let completedAtMs = -Infinity;
+  const consider = (value) => {
+    if (value === void 0)
+      return;
+    const ms = Date.parse(value);
+    if (Number.isNaN(ms))
+      return;
+    if (ms < startedAtMs) {
+      startedAtMs = ms;
+      startedAt = value;
+    }
+    if (ms > completedAtMs) {
+      completedAtMs = ms;
+      completedAt = value;
+    }
+  };
+  for (const item of items) {
+    consider(item.startedAt);
+    consider(item.completedAt);
+  }
+  return { startedAt, completedAt };
+}
+function responseBlocks(message, responseSequence, allocateStreamStage, forceFinalTextProvisional = false, promoteNarrationToFinal = false) {
+  const responseId = message.responseId ?? message.id;
+  const result = [];
+  for (const segment of textBlockSegments(message)) {
+    const effectivePhase = promoteNarrationToFinal && segment.phase === "narration" ? "final" : segment.phase;
+    const phase = forceFinalTextProvisional && !promoteNarrationToFinal && effectivePhase === "final" ? "provisional" : effectivePhase;
+    const blockBase = {
+      id: segment.id,
+      responseId,
+      sourceMessageId: message.id,
+      responseSequence,
+      streamStage: allocateStreamStage(),
+      status: messageStatus(message),
+      text: segment.text,
+      textOffset: segment.textOffset,
+      source: message,
+      ...segment.continuesResponse ? { continuesResponse: true } : {}
+    };
+    switch (phase) {
+      case "narration":
+        result.push({ kind: "narration", ...blockBase, phase: "narration" });
+        break;
+      case "final":
+        result.push({ kind: "final_answer", ...blockBase, phase: "final" });
+        break;
+      case "interrupted":
+      case "error":
+      case "provisional":
+      case void 0:
+        result.push({
+          kind: "provisional_response",
+          ...blockBase,
+          phase: phase ?? "provisional"
+        });
+        break;
+    }
+  }
+  message.parts.forEach((part, index) => {
+    if (part.type !== "unknown")
+      return;
+    result.push({
+      kind: "unknown_activity",
+      id: canonicalId("unknown-activity", `${responseId}:${index}`),
+      responseId,
+      sourceMessageId: message.id,
+      responseSequence,
+      ...part.providerType === void 0 ? {} : { providerType: part.providerType },
+      value: part.value,
+      source: message
+    });
+  });
+  return result;
+}
+function textBlockSegments(message) {
+  const responseId = message.responseId ?? message.id;
+  const singleBlockId = canonicalId("response-block", responseId);
+  const textParts = message.parts.filter((part) => part.type === "text");
+  const honorDeclared = message.status !== "streaming" && textParts.some((part) => part.declaredPhase !== void 0);
+  if (!honorDeclared) {
+    const text = message.text !== "" ? message.text : textParts.map((part) => part.text).join("");
+    if (!hasVisibleText(text) && !(message.role === "assistant" && message.status === "streaming" && message.parts.length === 0)) {
+      return [];
+    }
+    return [
+      { id: singleBlockId, phase: message.textPhase, text, textOffset: 0 }
+    ];
+  }
+  const runs = [];
+  let sourceOffset = 0;
+  for (const part of textParts) {
+    const phase = part.declaredPhase ?? message.textPhase;
+    const current = runs.at(-1);
+    if (current !== void 0 && current.phase === phase) {
+      current.text += part.text;
+    } else {
+      runs.push({ phase, text: part.text, textOffset: sourceOffset });
+    }
+    sourceOffset += part.text.length;
+  }
+  return runs.map((run, index) => ({
+    id: index === 0 ? singleBlockId : canonicalId("response-block", `${responseId}:${index}`),
+    phase: run.phase,
+    text: run.text,
+    textOffset: run.textOffset,
+    ...index > 0 ? { continuesResponse: true } : {}
+  })).filter((segment) => hasVisibleText(segment.text));
+}
+var VISIBLE_CHARACTER = /[^\p{White_Space}\p{Default_Ignorable_Code_Point}]/u;
+function hasVisibleText(text) {
+  return VISIBLE_CHARACTER.test(text);
+}
+function thinkingAnnotations(message) {
+  const responseId = message.responseId ?? message.id;
+  return message.parts.flatMap((part, index) => part.type === "thinking" ? [
+    {
+      id: canonicalId("thinking", `${responseId}:${index}`),
+      responseId,
+      sourceMessageId: message.id,
+      text: part.text
+    }
+  ] : []);
+}
+function projectWave(waveId, tools, responseSequence) {
+  const attempts = tools.map((tool) => projectAttempt(tool, waveId));
+  const first = tools[0];
+  const sequence = first?.sourceMessageId === void 0 ? void 0 : responseSequence.get(first.sourceMessageId);
+  return {
+    id: waveId,
+    ...first?.responseId === void 0 ? {} : { responseId: first.responseId },
+    ...first?.sourceMessageId === void 0 ? {} : { sourceMessageId: first.sourceMessageId },
+    ...sequence === void 0 ? {} : { responseSequence: sequence },
+    status: aggregateStatus(attempts.map(attemptLifecycleStatus)),
+    attempts
+  };
+}
+function projectAttempt(tool, canonicalWaveId2) {
+  const attemptId = tool.attemptId ?? canonicalId("tool-attempt", tool.id);
+  return {
+    id: attemptId,
+    waveId: canonicalWaveId2,
+    ...tool.backgroundTaskId === void 0 ? {} : { detached: true },
+    ...tool.responseId === void 0 ? {} : { responseId: tool.responseId },
+    ...tool.sourceMessageId === void 0 ? {} : { sourceMessageId: tool.sourceMessageId },
+    correlationId: tool.toolCallId,
+    generation: tool.attemptGeneration ?? 1,
+    status: toolStatus(tool),
+    ...optional("toolName", tool.name),
+    ...optional("input", tool.argumentsText),
+    ...optional("output", tool.resultText),
+    ...tool.resultDetails === void 0 ? {} : { resultDetails: tool.resultDetails },
+    ...finalOutputOf(tool),
+    ...optional("error", tool.errorText),
+    ...optional("startedAt", tool.startedAt),
+    ...optional("completedAt", tool.completedAt),
+    source: tool
+  };
+}
+function finalOutputOf(tool) {
+  if (tool.name !== RESERVED_FINAL_OUTPUT_TOOL_NAME)
+    return {};
+  const capture = finalOutputCaptureFromDetails(tool.toolCallId, tool.resultDetails);
+  return capture === void 0 ? {} : { finalOutput: capture };
+}
+function hasUserItemAfter(items, index) {
+  for (let scan = index + 1; scan < items.length; scan += 1) {
+    const candidate = items[scan];
+    if (candidate?.type === "message" && candidate.role === "user") {
+      return true;
+    }
+  }
+  return false;
+}
+function userItemIndexAfterById(items, index, id) {
+  for (let scan = index + 1; scan < items.length; scan += 1) {
+    const candidate = items[scan];
+    if (candidate?.type === "message" && candidate.role === "user" && candidate.id === id) {
+      return scan;
+    }
+  }
+  return -1;
+}
+function messageStatus(message) {
+  if (message.status === "streaming")
+    return "running";
+  const finishReason = message.finishReason;
+  if (finishReason === void 0) {
+    switch (message.status) {
+      case "interrupted":
+        return "interrupted";
+      case "error":
+        return "failed";
+      case "complete":
+        return "succeeded";
+    }
+  }
+  switch (finishReason) {
+    case "interrupted":
+      return "interrupted";
+    case "cancelled":
+      return "cancelled";
+    case "error":
+      return "failed";
+    case "complete":
+    case "tool_use":
+    case "unknown":
+      return "succeeded";
+  }
+}
+function toolStatus(tool) {
+  switch (tool.status) {
+    case "declared":
+    case "arguments_complete":
+      return "pending";
+    case "running":
+      return "running";
+    case "complete":
+      return "succeeded";
+    case "error":
+      return "failed";
+    case "interrupted":
+      return "interrupted";
+    case "cancelled":
+      return "cancelled";
+  }
+}
+function aggregateStatus(statuses) {
+  if (statuses.includes("failed"))
+    return "failed";
+  if (statuses.includes("interrupted"))
+    return "interrupted";
+  if (statuses.includes("cancelled"))
+    return "cancelled";
+  if (statuses.includes("running"))
+    return "running";
+  if (statuses.includes("pending"))
+    return "pending";
+  return "succeeded";
+}
+function agentTurnStatus(blocks, items, state, isLatestTurn, placements) {
+  const runStatus = isLatestTurn ? state.run.status : void 0;
+  if (runStatus === "aborted")
+    return "interrupted";
+  if (runStatus === "error")
+    return "failed";
+  const lastAssistant = items.findLast((item) => item.type === "message" && item.role === "assistant");
+  if (isLatestTurn && lastAssistant?.status === "streaming")
+    return "running";
+  const hasContinuation = continuationFollowsLastAssistant(items, placements);
+  const hasPendingBackground = isLatestTurn && hasPendingBackgroundWork(items, state);
+  const hasAwaitableResult = isLatestTurn && hasTrailingAwaitableResult(items);
+  if (runStatus === "running") {
+    if (hasContinuation)
+      return "running";
+    if (hasPendingBackground)
+      return "pending";
+    if (lastAssistant !== void 0) {
+      const terminal = terminalAssistantStatus(lastAssistant);
+      if (terminal !== void 0)
+        return terminal;
+    }
+    return "running";
+  }
+  if (lastAssistant?.runAborted)
+    return "interrupted";
+  if (hasPendingBackground || hasAwaitableResult)
+    return "pending";
+  if (hasTerminalFinalOutput(items))
+    return "succeeded";
+  if (hasExhaustedRequiredFinalOutputRepair(items))
+    return "failed";
+  if (lastAssistant !== void 0) {
+    const terminal = terminalAssistantStatus(lastAssistant);
+    if (terminal !== void 0)
+      return terminal;
+  }
+  const finalAnswer = blocks.findLast((block) => block.kind === "final_answer");
+  if (finalAnswer !== void 0)
+    return finalAnswer.status;
+  const statuses = new Set(blocks.flatMap((block) => {
+    switch (block.kind) {
+      case "narration":
+      case "provisional_response":
+      case "work_episode":
+        return [block.status];
+      // tool_surface is never produced; listed so this switch stays exhaustive.
+      case "tool_surface":
+      case "custom_message":
+      case "steer_message":
+      case "unknown_activity":
+        return [];
+      case "final_answer":
+        return [block.status];
+    }
+  }));
+  const responseFailed = blocks.some((block) => (block.kind === "narration" || block.kind === "provisional_response" || block.kind === "final_answer") && block.status === "failed");
+  if (responseFailed)
+    return "failed";
+  if (statuses.has("interrupted"))
+    return "interrupted";
+  if (statuses.has("cancelled"))
+    return "cancelled";
+  if (statuses.has("running"))
+    return "running";
+  if (statuses.has("pending"))
+    return "pending";
+  return "succeeded";
+}
+function completedPrefixItemCount(items, completedRunBoundaryItemIds) {
+  let prefixEnd = 0;
+  let endedAt = 0;
+  let endedWaveId;
+  let continuationStart;
+  for (let index = 0; index < items.length; index += 1) {
+    const item = items[index];
+    if (completedRunBoundaryItemIds?.has(boundaryAnchorKey(item)) === true) {
+      endedAt = index + 1;
+      endedWaveId = item.type === "tool" ? canonicalToolWaveId(item) : void 0;
+      continuationStart = void 0;
+      continue;
+    }
+    if (item.type === "tool" && item.backgroundTaskId === void 0 && (toolStatus(item) === "running" || toolStatus(item) === "pending")) {
+      return endedAt > 0 && canonicalToolWaveId(item) !== endedWaveId ? endedAt : prefixEnd;
+    }
+    if (item.type === "message") {
+      if (isRequiredFinalOutputRepairMessage(item)) {
+        endedAt = 0;
+        endedWaveId = void 0;
+        continuationStart = void 0;
+        continue;
+      }
+      if (item.role === "custom" && item.customType === COMPACTION_MARKER_CUSTOM_TYPE) {
+        if (endedAt > 0)
+          endedAt = index + 1;
+        continue;
+      }
+      if (isEmbeddedAgentResultMessage(item) || isDaemonWakeMessage(item)) {
+        continuationStart ??= index;
+        if (endedAt > 0)
+          prefixEnd = endedAt;
+        endedAt = 0;
+        endedWaveId = void 0;
+        if (isDaemonWakeMessage(item))
+          prefixEnd = Math.max(prefixEnd, continuationStart);
+        continue;
+      }
+      if (item.role !== "assistant" && item.role !== "user") {
+        if (endedAt > 0)
+          endedAt = index + 1;
+        continue;
+      }
+    }
+    if (endedAt > 0 && endedWaveId !== void 0 && item.type === "tool" && canonicalToolWaveId(item) === endedWaveId) {
+      endedAt = index + 1;
+      continue;
+    }
+    if (endedAt > 0)
+      prefixEnd = endedAt;
+    endedAt = 0;
+    endedWaveId = void 0;
+    continuationStart = void 0;
+    if (item.type === "message" && item.role === "assistant" && item.status === "complete" && terminalAssistantStatus(item) === "succeeded" || isTerminalFinalOutput(items, index)) {
+      endedAt = index + 1;
+      if (item.type === "tool")
+        endedWaveId = canonicalToolWaveId(item);
+    }
+  }
+  return endedAt > 0 ? items.length : prefixEnd;
+}
+function terminalAssistantStatus(message) {
+  const finishReason = message.finishReason;
+  if (finishReason === void 0) {
+    if (message.status === "error")
+      return "failed";
+    if (message.status === "interrupted")
+      return "interrupted";
+    return void 0;
+  }
+  switch (finishReason) {
+    case "error":
+      return "failed";
+    case "interrupted":
+      return "interrupted";
+    case "cancelled":
+      return "cancelled";
+    case "complete":
+      return "succeeded";
+    case "tool_use":
+    case "unknown":
+      return void 0;
+  }
+}
+function canonicalSourceId(item) {
+  return item.type === "tool" ? item.attemptId ?? canonicalId("tool-attempt", item.id) : item.id;
+}
+function optional(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+
+// packages/herd-transcript/dist/interactive/reconstruct.js
+function eventsForEntry(entry) {
+  if (entry.type === "compaction") {
+    return [
+      {
+        type: "session_compact",
+        compactionEntry: entry,
+        timestamp: entry.timestamp
+      }
+    ];
+  }
+  if (entry.type === "custom") {
+    const boundary = runBoundaryReplayEvent(entry);
+    return boundary === void 0 ? [] : [boundary];
+  }
+  if (entry.type !== void 0 && entry.type !== "message")
+    return [];
+  const body = asRecord3(entry.message);
+  const role = body?.["role"];
+  if (role === TOOL_RESULT_ROLE) {
+    const toolCallId = body?.["toolCallId"];
+    const isError = body?.["isError"] === true;
+    const resultText = contentText(body?.["content"]);
+    return [
+      {
+        type: "tool_execution_end",
+        ...entry.id !== void 0 ? { entryId: entry.id } : {},
+        toolCallId,
+        toolName: body?.["toolName"],
+        content: body?.["content"],
+        details: body?.["details"],
+        isError,
+        timestamp: entry.timestamp,
+        ...isError && resultText !== void 0 ? { error: resultText } : {}
+      }
+    ];
+  }
+  const base = {
+    ...entry.id !== void 0 ? { id: entry.id, entryId: entry.id } : {},
+    message: entry.message,
+    timestamp: entry.timestamp
+  };
+  return [
+    { ...base, type: "message_start" },
+    { ...base, type: "message_end" }
+  ];
+}
+function reconstructInteractiveState(entries) {
+  function* replayEvents() {
+    for (const entry of entries) {
+      for (const event of eventsForEntry(entry)) {
+        yield event;
+      }
+    }
+  }
+  return reduceInteractiveModeEventsForReplay(replayEvents());
+}
+function runBoundaryReplayEvent(entry) {
+  if (entry.type !== "custom" || entry.customType !== "session_run_state") {
+    return void 0;
+  }
+  const data = asRecord3(entry.data);
+  const runState = data?.["runState"];
+  switch (runState) {
+    case "completed":
+    case "failed":
+    case "interrupted":
+    case "cancelled":
+      return {
+        type: "host_run_status",
+        run: {
+          status: "settled",
+          // Bare cancelled entries predate the interrupt/cancel split.
+          outcome: runState === "cancelled" && data?.["stop"] === void 0 ? "interrupted" : runState
+        }
+      };
+    default:
+      return void 0;
+  }
+}
+function contentText(content) {
+  if (typeof content === "string")
+    return content === "" ? void 0 : content;
+  if (!Array.isArray(content))
+    return void 0;
+  const text = content.flatMap((part) => {
+    const record = asRecord3(part);
+    const value = record?.["text"];
+    return typeof value === "string" ? [value] : [];
+  }).join("");
+  return text === "" ? void 0 : text;
+}
+function asRecord3(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+export {
+  customMessagePlacement,
+  eventsForEntry,
+  projectCanonicalTranscript,
+  reconstructInteractiveState,
+  runBoundaryReplayEvent
+};