@athenaintel/react 0.28.1 → 0.32.0

package/dist/chat/super-grouping/turn-segments.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The grouped transcript's layout of one assistant turn: the agent's own
+ * sentences in the order it wrote them, with the work between them (tool calls
+ * and reasoning) folded into collapsed activity segments. Pure functions over
+ * assistant-ui message parts; `SuperGroupingTranscript` renders them.
+ *
+ * Text is never folded away. The text after the final tool call is the turn's
+ * answer and renders below the transcript (`SuperGroupingFinalText`, the same
+ * read `getFinalText` makes), so it is left out of the segments here: every
+ * text part renders exactly once, either as prose here or as the answer there.
+ */
+import type { ActivityItem, ActivityPhase } from './activity-timeline';
+import type { GroupingFunction } from './grouping-function';
+import type { TimelineStep } from './timeline-step';
+/** The part shape segmentation needs; assistant-ui's `ThreadAssistantMessagePart` satisfies it. */
+export type SegmentablePart = {
+    readonly type: string;
+    readonly text?: string;
+};
+export type TurnSegment = {
+    kind: 'prose';
+    /** Stable across streaming: parts only ever append. */
+    key: string;
+    partIndex: number;
+    text: string;
+} | {
+    kind: 'activity';
+    key: string;
+    /** The tool-call, reasoning and other non-text parts this segment folds, in order. */
+    partIndices: number[];
+};
+/**
+ * Split a turn into prose and activity segments.
+ *
+ * - Before the last tool call, each non-blank text part is a prose segment and
+ *   every run of other parts between them is one activity segment.
+ * - After the last tool call, text is the answer (left to the final-text
+ *   renderer), and any other part — a thought streaming before the next
+ *   sentence — joins the last activity segment, so it reads as part of the
+ *   work that led to the answer.
+ */
+export declare function splitTurnSegments(content: readonly SegmentablePart[] | undefined): TurnSegment[];
+/** The timeline items whose parts a segment folds, in stream order. */
+export declare function segmentItems(segment: Extract<TurnSegment, {
+    kind: 'activity';
+}>, timeline: readonly ActivityItem[]): ActivityItem[];
+/**
+ * The details-panel grouping for one segment: the host's grouping restricted
+ * to the segment's parts, with every text part dropped (prose renders in the
+ * transcript, the answer below it) and any group left empty removed.
+ */
+export declare function scopeGroupingToSegment(grouping: GroupingFunction, partIndices: readonly number[]): GroupingFunction;
+export interface SegmentSummary {
+    /** The collapsed row's line: the step in progress, else the segment's last tool step. */
+    step: TimelineStep | undefined;
+    /** "Waiting for your input" when a step waits on the person. */
+    label: string;
+    /** "+2 more" / "2 in progress" beside the line. */
+    meta: string | undefined;
+    phase: ActivityPhase;
+}
+/**
+ * What a collapsed activity segment says: the step in progress while one runs
+ * ("Running git fetch", with "2 done" or "2 in progress" for parallel calls), the step
+ * waiting on the person, else the last tool step it took ("Ran git log -1",
+ * "+2 more", and how many earlier steps failed). The row reads as failed only
+ * when that last step did. A segment that only thought reads as its thought.
+ */
+export declare function summarizeSegment(steps: readonly TimelineStep[]): SegmentSummary;

package/dist/chat/super-grouping/turn-segments.js

@@ -0,0 +1,82 @@
+function lastToolCallIndex(content) {
+  var _a;
+  for (let index = content.length - 1; index >= 0; index -= 1) {
+    if (((_a = content[index]) == null ? void 0 : _a.type) === "tool-call") return index;
+  }
+  return -1;
+}
+function splitTurnSegments(content) {
+  if (!(content == null ? void 0 : content.length)) return [];
+  const answerStart = lastToolCallIndex(content) + 1;
+  const segments = [];
+  let lastActivity = null;
+  for (let index = 0; index < content.length; index += 1) {
+    const part = content[index];
+    if (!part) continue;
+    if (part.type === "text") {
+      if (index >= answerStart) continue;
+      const text = typeof part.text === "string" ? part.text : "";
+      if (text.trim() === "") continue;
+      segments.push({ kind: "prose", key: `prose-${index}`, partIndex: index, text });
+      continue;
+    }
+    const previous = segments.at(-1);
+    if (index < answerStart && (previous == null ? void 0 : previous.kind) === "activity") {
+      previous.partIndices.push(index);
+      continue;
+    }
+    if (index >= answerStart && lastActivity) {
+      lastActivity.partIndices.push(index);
+      continue;
+    }
+    lastActivity = { kind: "activity", key: `activity-${index}`, partIndices: [index] };
+    segments.push(lastActivity);
+  }
+  return segments;
+}
+function scopeGroupingToSegment(grouping, partIndices) {
+  const indices = new Set(partIndices);
+  return (parts) => grouping(parts).map((group) => ({
+    ...group,
+    indices: group.indices.filter((index) => {
+      var _a;
+      return indices.has(index) && ((_a = parts[index]) == null ? void 0 : _a.type) !== "text";
+    })
+  })).filter((group) => group.indices.length > 0);
+}
+function summarizeSegment(steps) {
+  const toolSteps = steps.filter((step) => step.kind === "tool");
+  const running = steps.filter((step) => step.state === "running");
+  const waiting = steps.find((step) => step.state === "waiting");
+  if (waiting) {
+    return { step: waiting, label: waiting.verb, meta: void 0, phase: "waiting" };
+  }
+  if (running.length > 0) {
+    const current = running.at(-1);
+    const doneTools = toolSteps.filter((step) => step.state !== "running").length;
+    return {
+      step: current,
+      label: (current == null ? void 0 : current.verb) ?? "Working",
+      meta: running.length > 1 ? `${running.length} in progress` : doneTools > 0 ? `${doneTools} done` : void 0,
+      phase: "running"
+    };
+  }
+  const primary = toolSteps.at(-1) ?? steps.at(-1);
+  const earlierFailures = toolSteps.filter((step) => step !== primary && step.state === "error").length;
+  const meta = [
+    toolSteps.length > 1 ? `+${toolSteps.length - 1} more` : null,
+    earlierFailures > 0 ? `${earlierFailures} failed` : null
+  ].filter(Boolean).join(" · ");
+  return {
+    step: primary,
+    label: (primary == null ? void 0 : primary.verb) ?? "Thought through the next step",
+    meta: meta || void 0,
+    phase: (primary == null ? void 0 : primary.state) === "error" ? "error" : "complete"
+  };
+}
+export {
+  scopeGroupingToSegment,
+  splitTurnSegments,
+  summarizeSegment
+};
+//# sourceMappingURL=turn-segments.js.map

package/dist/chat/super-grouping/turn-segments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-segments.js","sources":["../../../src/chat/super-grouping/turn-segments.ts"],"sourcesContent":["/**\n * The grouped transcript's layout of one assistant turn: the agent's own\n * sentences in the order it wrote them, with the work between them (tool calls\n * and reasoning) folded into collapsed activity segments. Pure functions over\n * assistant-ui message parts; `SuperGroupingTranscript` renders them.\n *\n * Text is never folded away. The text after the final tool call is the turn's\n * answer and renders below the transcript (`SuperGroupingFinalText`, the same\n * read `getFinalText` makes), so it is left out of the segments here: every\n * text part renders exactly once, either as prose here or as the answer there.\n */\nimport type { ActivityItem, ActivityPhase } from './activity-timeline';\nimport type { GroupingFunction } from './grouping-function';\nimport type { TimelineStep } from './timeline-step';\n\n/** The part shape segmentation needs; assistant-ui's `ThreadAssistantMessagePart` satisfies it. */\nexport type SegmentablePart = { readonly type: string; readonly text?: string };\n\nexport type TurnSegment =\n  | {\n      kind: 'prose';\n      /** Stable across streaming: parts only ever append. */\n      key: string;\n      partIndex: number;\n      text: string;\n    }\n  | {\n      kind: 'activity';\n      key: string;\n      /** The tool-call, reasoning and other non-text parts this segment folds, in order. */\n      partIndices: number[];\n    };\n\nfunction lastToolCallIndex(content: readonly SegmentablePart[]): number {\n  for (let index = content.length - 1; index >= 0; index -= 1) {\n    if (content[index]?.type === 'tool-call') return index;\n  }\n  return -1;\n}\n\n/**\n * Split a turn into prose and activity segments.\n *\n * - Before the last tool call, each non-blank text part is a prose segment and\n *   every run of other parts between them is one activity segment.\n * - After the last tool call, text is the answer (left to the final-text\n *   renderer), and any other part — a thought streaming before the next\n *   sentence — joins the last activity segment, so it reads as part of the\n *   work that led to the answer.\n */\nexport function splitTurnSegments(content: readonly SegmentablePart[] | undefined): TurnSegment[] {\n  if (!content?.length) return [];\n  const answerStart = lastToolCallIndex(content) + 1;\n  const segments: TurnSegment[] = [];\n  let lastActivity: Extract<TurnSegment, { kind: 'activity' }> | null = null;\n\n  for (let index = 0; index < content.length; index += 1) {\n    const part = content[index];\n    if (!part) continue;\n    if (part.type === 'text') {\n      if (index >= answerStart) continue;\n      const text = typeof part.text === 'string' ? part.text : '';\n      if (text.trim() === '') continue;\n      segments.push({ kind: 'prose', key: `prose-${index}`, partIndex: index, text });\n      continue;\n    }\n    const previous = segments.at(-1);\n    if (index < answerStart && previous?.kind === 'activity') {\n      previous.partIndices.push(index);\n      continue;\n    }\n    if (index >= answerStart && lastActivity) {\n      lastActivity.partIndices.push(index);\n      continue;\n    }\n    lastActivity = { kind: 'activity', key: `activity-${index}`, partIndices: [index] };\n    segments.push(lastActivity);\n  }\n  return segments;\n}\n\n/** The timeline items whose parts a segment folds, in stream order. */\nexport function segmentItems(\n  segment: Extract<TurnSegment, { kind: 'activity' }>,\n  timeline: readonly ActivityItem[],\n): ActivityItem[] {\n  const indices = new Set(segment.partIndices);\n  return timeline.filter((item) => item.partIndex !== undefined && indices.has(item.partIndex));\n}\n\n/**\n * The details-panel grouping for one segment: the host's grouping restricted\n * to the segment's parts, with every text part dropped (prose renders in the\n * transcript, the answer below it) and any group left empty removed.\n */\nexport function scopeGroupingToSegment(\n  grouping: GroupingFunction,\n  partIndices: readonly number[],\n): GroupingFunction {\n  const indices = new Set(partIndices);\n  return (parts) =>\n    grouping(parts)\n      .map((group) => ({\n        ...group,\n        indices: group.indices.filter((index) => indices.has(index) && parts[index]?.type !== 'text'),\n      }))\n      .filter((group) => group.indices.length > 0);\n}\n\nexport interface SegmentSummary {\n  /** The collapsed row's line: the step in progress, else the segment's last tool step. */\n  step: TimelineStep | undefined;\n  /** \"Waiting for your input\" when a step waits on the person. */\n  label: string;\n  /** \"+2 more\" / \"2 in progress\" beside the line. */\n  meta: string | undefined;\n  phase: ActivityPhase;\n}\n\n/**\n * What a collapsed activity segment says: the step in progress while one runs\n * (\"Running git fetch\", with \"2 done\" or \"2 in progress\" for parallel calls), the step\n * waiting on the person, else the last tool step it took (\"Ran git log -1\",\n * \"+2 more\", and how many earlier steps failed). The row reads as failed only\n * when that last step did. A segment that only thought reads as its thought.\n */\nexport function summarizeSegment(steps: readonly TimelineStep[]): SegmentSummary {\n  const toolSteps = steps.filter((step) => step.kind === 'tool');\n  const running = steps.filter((step) => step.state === 'running');\n  const waiting = steps.find((step) => step.state === 'waiting');\n\n  if (waiting) {\n    return { step: waiting, label: waiting.verb, meta: undefined, phase: 'waiting' };\n  }\n  if (running.length > 0) {\n    const current = running.at(-1);\n    const doneTools = toolSteps.filter((step) => step.state !== 'running').length;\n    return {\n      step: current,\n      label: current?.verb ?? 'Working',\n      meta:\n        running.length > 1\n          ? `${running.length} in progress`\n          : doneTools > 0\n            ? `${doneTools} done`\n            : undefined,\n      phase: 'running',\n    };\n  }\n  const primary = toolSteps.at(-1) ?? steps.at(-1);\n  const earlierFailures = toolSteps.filter((step) => step !== primary && step.state === 'error').length;\n  const meta = [\n    toolSteps.length > 1 ? `+${toolSteps.length - 1} more` : null,\n    earlierFailures > 0 ? `${earlierFailures} failed` : null,\n  ]\n    .filter(Boolean)\n    .join(' · ');\n  return {\n    step: primary,\n    label: primary?.verb ?? 'Thought through the next step',\n    meta: meta || undefined,\n    phase: primary?.state === 'error' ? 'error' : 'complete',\n  };\n}\n"],"names":[],"mappings":"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"}

package/dist/chat/super-grouping/turn-timing.cjs

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const messageTime = require("../message-time.cjs");
+const messages = require("../../agent-runtime/src/messages.cjs");
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readInstantMs(value) {
+  var _a;
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return value > 1e12 ? value : value * 1e3;
+  }
+  return ((_a = messageTime.parseMessageTime(value)) == null ? void 0 : _a.getTime()) ?? null;
+}
+function sourceMetadata(message) {
+  var _a;
+  const kwargs = record((_a = record(message)) == null ? void 0 : _a.additional_kwargs);
+  return record(kwargs == null ? void 0 : kwargs.metadata) ?? kwargs;
+}
+function isRunMarker(message) {
+  var _a, _b;
+  return typeof ((_b = record((_a = record(message)) == null ? void 0 : _a.additional_kwargs)) == null ? void 0 : _b[messages.ATHENA_RUN_MARKER_KEY]) === "string";
+}
+function readTurnTiming({ promptCreatedAt, custom, sourceMessages }) {
+  let endMs = null;
+  let firstStampMs = null;
+  let serverStartMs = null;
+  let serverDurationMs = null;
+  let afterMarker = false;
+  let continuedAtMs = null;
+  for (const message of sourceMessages) {
+    if (isRunMarker(message)) {
+      afterMarker = true;
+      continuedAtMs = null;
+      serverDurationMs = null;
+      continue;
+    }
+    const metadata = sourceMetadata(message);
+    const stamp = readInstantMs(metadata == null ? void 0 : metadata[messageTime.MESSAGE_CREATED_AT_KEY]);
+    if (stamp !== null) {
+      firstStampMs ?? (firstStampMs = stamp);
+      if (afterMarker) continuedAtMs ?? (continuedAtMs = stamp);
+      endMs = endMs === null ? stamp : Math.max(endMs, stamp);
+    }
+    const duration = metadata == null ? void 0 : metadata.agent_duration_seconds;
+    if (typeof duration === "number" && Number.isFinite(duration) && duration > 0) {
+      serverDurationMs = duration * 1e3;
+      serverStartMs = readInstantMs(metadata == null ? void 0 : metadata.agent_start_time) ?? serverStartMs;
+    }
+  }
+  if (serverStartMs !== null && serverDurationMs !== null) {
+    const serverEnd = serverStartMs + serverDurationMs;
+    endMs = endMs === null ? serverEnd : Math.max(endMs, serverEnd);
+  }
+  const startMs = continuedAtMs ?? readInstantMs(promptCreatedAt) ?? serverStartMs ?? readInstantMs(custom == null ? void 0 : custom.agent_start_time) ?? readInstantMs(custom == null ? void 0 : custom.run_started_at) ?? readInstantMs(custom == null ? void 0 : custom[messageTime.MESSAGE_CREATED_AT_KEY]) ?? firstStampMs;
+  return { startMs, endMs, serverDurationMs };
+}
+function workedDurationMs({ startMs, endMs, serverDurationMs }, observedEndMs = null) {
+  const observed = observedEndMs !== null && (endMs === null || observedEndMs - endMs <= MAX_OBSERVED_END_LAG_MS) ? observedEndMs : null;
+  const end = serverDurationMs !== null || observed === null ? endMs : endMs === null ? observed : Math.max(endMs, observed);
+  if (startMs !== null && end !== null && end >= startMs) {
+    return Math.max(end - startMs, serverDurationMs ?? 0);
+  }
+  return serverDurationMs;
+}
+const MAX_OBSERVED_END_LAG_MS = 10 * 60 * 1e3;
+function formatWorkDuration(ms) {
+  const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  if (totalMinutes < 60) return `${totalMinutes}m ${String(totalSeconds % 60).padStart(2, "0")}s`;
+  const hours = Math.floor(totalMinutes / 60);
+  return `${hours}h ${String(totalMinutes % 60).padStart(2, "0")}m`;
+}
+function workingLabel(elapsedMs) {
+  return elapsedMs < 1e3 ? "Working" : `Working for ${formatWorkDuration(elapsedMs)}`;
+}
+const MAX_FIRST_SEEN = 200;
+const firstSeen = /* @__PURE__ */ new Map();
+function firstSeenMs(key, now = Date.now()) {
+  const seen = firstSeen.get(key);
+  if (seen !== void 0) return seen;
+  firstSeen.set(key, now);
+  if (firstSeen.size > MAX_FIRST_SEEN) {
+    const oldest = firstSeen.keys().next().value;
+    if (oldest !== void 0) firstSeen.delete(oldest);
+  }
+  return now;
+}
+const observedEnds = /* @__PURE__ */ new Map();
+function recordObservedTurnEnd(key, now = Date.now()) {
+  observedEnds.set(key, now);
+  if (observedEnds.size > MAX_FIRST_SEEN) {
+    const oldest = observedEnds.keys().next().value;
+    if (oldest !== void 0) observedEnds.delete(oldest);
+  }
+  return now;
+}
+function observedTurnEndMs(key) {
+  return observedEnds.get(key) ?? null;
+}
+exports.firstSeenMs = firstSeenMs;
+exports.formatWorkDuration = formatWorkDuration;
+exports.observedTurnEndMs = observedTurnEndMs;
+exports.readInstantMs = readInstantMs;
+exports.readTurnTiming = readTurnTiming;
+exports.recordObservedTurnEnd = recordObservedTurnEnd;
+exports.workedDurationMs = workedDurationMs;
+exports.workingLabel = workingLabel;
+//# sourceMappingURL=turn-timing.cjs.map

package/dist/chat/super-grouping/turn-timing.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-timing.cjs","sources":["../../../src/chat/super-grouping/turn-timing.ts"],"sourcesContent":["/**\n * How long an assistant turn has been working, or worked — the grouped\n * transcript's \"Working for 1m 12s\" / \"Worked for 2m 30s\" header.\n *\n * Every clock here is a server stamp the runtime already writes: `_created_at`\n * on each message (`additional_kwargs.metadata`, surfaced as\n * `metadata.custom`), and on the turn's final assistant message the\n * turn-timing middleware's `agent_start_time` / `agent_duration_seconds`\n * (epoch seconds). The converter joins only the first assistant message's\n * metadata into the turn, so the end of the turn is read off the raw messages\n * bound to it. assistant-ui's own `createdAt` is when this client first saw the\n * message, so it is never used.\n */\nimport { ATHENA_RUN_MARKER_KEY } from '@athenaintel/agent-runtime';\nimport { MESSAGE_CREATED_AT_KEY, parseMessageTime } from '../message-time';\n\nexport interface TurnTiming {\n  /**\n   * When the turn started: the prompt's stamp, else the run's own start\n   * stamps. A turn that was stopped and then continued starts at its\n   * continuation, so the clock never counts the time it sat stopped.\n   */\n  startMs: number | null;\n  /** When the turn's last message was written, from the server's stamps. */\n  endMs: number | null;\n  /** The turn-timing middleware's duration, when the final message carries it. */\n  serverDurationMs: number | null;\n}\n\nexport interface TurnTimingSources {\n  /** `_created_at` of the user message this turn answers. */\n  promptCreatedAt: string | null | undefined;\n  /** The turn's joined `metadata.custom` (its first assistant message's). */\n  custom: Record<string, unknown> | undefined;\n  /** The raw messages bound to the turn (`getExternalStoreMessages`), oldest first. */\n  sourceMessages: readonly unknown[];\n}\n\nfunction record(value: unknown): Record<string, unknown> | undefined {\n  return value && typeof value === 'object' && !Array.isArray(value)\n    ? (value as Record<string, unknown>)\n    : undefined;\n}\n\n/** An instant from an ISO stamp or epoch seconds (milliseconds past 1e12), else `null`. */\nexport function readInstantMs(value: unknown): number | null {\n  if (typeof value === 'number' && Number.isFinite(value) && value > 0) {\n    return value > 1e12 ? value : value * 1000;\n  }\n  return parseMessageTime(value)?.getTime() ?? null;\n}\n\nfunction sourceMetadata(message: unknown): Record<string, unknown> | undefined {\n  const kwargs = record(record(message)?.additional_kwargs);\n  return record(kwargs?.metadata) ?? kwargs;\n}\n\nfunction isRunMarker(message: unknown): boolean {\n  return typeof record(record(message)?.additional_kwargs)?.[ATHENA_RUN_MARKER_KEY] === 'string';\n}\n\n/** The turn's start, end and server-measured duration from the stamps it carries. */\nexport function readTurnTiming({ promptCreatedAt, custom, sourceMessages }: TurnTimingSources): TurnTiming {\n  let endMs: number | null = null;\n  let firstStampMs: number | null = null;\n  let serverStartMs: number | null = null;\n  let serverDurationMs: number | null = null;\n  let afterMarker = false;\n  let continuedAtMs: number | null = null;\n  for (const message of sourceMessages) {\n    if (isRunMarker(message)) {\n      afterMarker = true;\n      continuedAtMs = null;\n      serverDurationMs = null;\n      continue;\n    }\n    const metadata = sourceMetadata(message);\n    const stamp = readInstantMs(metadata?.[MESSAGE_CREATED_AT_KEY]);\n    if (stamp !== null) {\n      firstStampMs ??= stamp;\n      if (afterMarker) continuedAtMs ??= stamp;\n      endMs = endMs === null ? stamp : Math.max(endMs, stamp);\n    }\n    const duration = metadata?.agent_duration_seconds;\n    if (typeof duration === 'number' && Number.isFinite(duration) && duration > 0) {\n      serverDurationMs = duration * 1000;\n      serverStartMs = readInstantMs(metadata?.agent_start_time) ?? serverStartMs;\n    }\n  }\n  if (serverStartMs !== null && serverDurationMs !== null) {\n    const serverEnd = serverStartMs + serverDurationMs;\n    endMs = endMs === null ? serverEnd : Math.max(endMs, serverEnd);\n  }\n  // Without a prompt stamp the run's own server clock comes before any\n  // assistant stamp: the first assistant message is written after the turn\n  // has already been working (thinking, the first tool), so starting there\n  // would drop that time.\n  const startMs =\n    continuedAtMs ??\n    readInstantMs(promptCreatedAt) ??\n    serverStartMs ??\n    readInstantMs(custom?.agent_start_time) ??\n    readInstantMs(custom?.run_started_at) ??\n    readInstantMs(custom?.[MESSAGE_CREATED_AT_KEY]) ??\n    firstStampMs;\n  return { startMs, endMs, serverDurationMs };\n}\n\n/**\n * How long a finished turn worked: from its start to its end, else the\n * server-measured duration, else `null` (nothing truthful to show).\n *\n * The end is the server's own turn clock when the final message carries it.\n * The turn-timing stamp lands on that message only after it has streamed, so a\n * turn watched live can settle before the stamp reaches this client; the last\n * message's `_created_at` is then the start of the final answer, not its end,\n * and `observedEndMs` (when this client saw the turn settle) stands in for it.\n */\nexport function workedDurationMs(\n  { startMs, endMs, serverDurationMs }: TurnTiming,\n  observedEndMs: number | null = null,\n): number | null {\n  // A settle seen long after the last stamp is not this turn's end (a thread\n  // opened while its status was still catching up), so it is ignored.\n  const observed =\n    observedEndMs !== null && (endMs === null || observedEndMs - endMs <= MAX_OBSERVED_END_LAG_MS)\n      ? observedEndMs\n      : null;\n  const end =\n    serverDurationMs !== null || observed === null\n      ? endMs\n      : endMs === null\n        ? observed\n        : Math.max(endMs, observed);\n  // The server's own duration is a floor: a start read off a later stamp\n  // never shortens the turn below what the server measured.\n  if (startMs !== null && end !== null && end >= startMs) {\n    return Math.max(end - startMs, serverDurationMs ?? 0);\n  }\n  return serverDurationMs;\n}\n\n/** How far past its last stamp a turn may be seen to settle and still count as its end. */\nconst MAX_OBSERVED_END_LAG_MS = 10 * 60 * 1000;\n\n/** \"45s\", \"1m 12s\", \"1h 03m\". */\nexport function formatWorkDuration(ms: number): string {\n  const totalSeconds = Math.max(0, Math.floor(ms / 1000));\n  if (totalSeconds < 60) return `${totalSeconds}s`;\n  const totalMinutes = Math.floor(totalSeconds / 60);\n  if (totalMinutes < 60) return `${totalMinutes}m ${String(totalSeconds % 60).padStart(2, '0')}s`;\n  const hours = Math.floor(totalMinutes / 60);\n  return `${hours}h ${String(totalMinutes % 60).padStart(2, '0')}m`;\n}\n\n/** The live header: \"Working\" for the first second, then \"Working for 1m 12s\". */\nexport function workingLabel(elapsedMs: number): string {\n  return elapsedMs < 1000 ? 'Working' : `Working for ${formatWorkDuration(elapsedMs)}`;\n}\n\n/** The settled header: \"Worked for 2m 30s\", or `null` when the turn carries no usable stamps. */\nexport function workedLabel(timing: TurnTiming): string | null {\n  const worked = workedDurationMs(timing);\n  return worked === null ? null : `Worked for ${formatWorkDuration(worked)}`;\n}\n\nconst MAX_FIRST_SEEN = 200;\nconst firstSeen = new Map<string, number>();\n\n/**\n * The first time this client saw a turn, for a live clock with no server stamp\n * to anchor on yet (an optimistic prompt before the server echoes it). Keyed\n * per turn, so a later turn never inherits an earlier one's start; bounded.\n */\nexport function firstSeenMs(key: string, now = Date.now()): number {\n  const seen = firstSeen.get(key);\n  if (seen !== undefined) return seen;\n  firstSeen.set(key, now);\n  if (firstSeen.size > MAX_FIRST_SEEN) {\n    const oldest = firstSeen.keys().next().value;\n    if (oldest !== undefined) firstSeen.delete(oldest);\n  }\n  return now;\n}\n\nconst observedEnds = new Map<string, number>();\n\n/** Record that this client saw the turn `key` settle at `now`; returns the recorded instant. */\nexport function recordObservedTurnEnd(key: string, now = Date.now()): number {\n  observedEnds.set(key, now);\n  if (observedEnds.size > MAX_FIRST_SEEN) {\n    const oldest = observedEnds.keys().next().value;\n    if (oldest !== undefined) observedEnds.delete(oldest);\n  }\n  return now;\n}\n\n/** When this client saw the turn `key` settle, if it watched it do so. */\nexport function observedTurnEndMs(key: string): number | null {\n  return observedEnds.get(key) ?? null;\n}\n\nexport function resetFirstSeenForTests(): void {\n  firstSeen.clear();\n  observedEnds.clear();\n}\n"],"names":["parseMessageTime","ATHENA_RUN_MARKER_KEY","MESSAGE_CREATED_AT_KEY"],"mappings":"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"}

package/dist/chat/super-grouping/turn-timing.d.ts

@@ -0,0 +1,52 @@
+export interface TurnTiming {
+    /**
+     * When the turn started: the prompt's stamp, else the run's own start
+     * stamps. A turn that was stopped and then continued starts at its
+     * continuation, so the clock never counts the time it sat stopped.
+     */
+    startMs: number | null;
+    /** When the turn's last message was written, from the server's stamps. */
+    endMs: number | null;
+    /** The turn-timing middleware's duration, when the final message carries it. */
+    serverDurationMs: number | null;
+}
+export interface TurnTimingSources {
+    /** `_created_at` of the user message this turn answers. */
+    promptCreatedAt: string | null | undefined;
+    /** The turn's joined `metadata.custom` (its first assistant message's). */
+    custom: Record<string, unknown> | undefined;
+    /** The raw messages bound to the turn (`getExternalStoreMessages`), oldest first. */
+    sourceMessages: readonly unknown[];
+}
+/** An instant from an ISO stamp or epoch seconds (milliseconds past 1e12), else `null`. */
+export declare function readInstantMs(value: unknown): number | null;
+/** The turn's start, end and server-measured duration from the stamps it carries. */
+export declare function readTurnTiming({ promptCreatedAt, custom, sourceMessages }: TurnTimingSources): TurnTiming;
+/**
+ * How long a finished turn worked: from its start to its end, else the
+ * server-measured duration, else `null` (nothing truthful to show).
+ *
+ * The end is the server's own turn clock when the final message carries it.
+ * The turn-timing stamp lands on that message only after it has streamed, so a
+ * turn watched live can settle before the stamp reaches this client; the last
+ * message's `_created_at` is then the start of the final answer, not its end,
+ * and `observedEndMs` (when this client saw the turn settle) stands in for it.
+ */
+export declare function workedDurationMs({ startMs, endMs, serverDurationMs }: TurnTiming, observedEndMs?: number | null): number | null;
+/** "45s", "1m 12s", "1h 03m". */
+export declare function formatWorkDuration(ms: number): string;
+/** The live header: "Working" for the first second, then "Working for 1m 12s". */
+export declare function workingLabel(elapsedMs: number): string;
+/** The settled header: "Worked for 2m 30s", or `null` when the turn carries no usable stamps. */
+export declare function workedLabel(timing: TurnTiming): string | null;
+/**
+ * The first time this client saw a turn, for a live clock with no server stamp
+ * to anchor on yet (an optimistic prompt before the server echoes it). Keyed
+ * per turn, so a later turn never inherits an earlier one's start; bounded.
+ */
+export declare function firstSeenMs(key: string, now?: number): number;
+/** Record that this client saw the turn `key` settle at `now`; returns the recorded instant. */
+export declare function recordObservedTurnEnd(key: string, now?: number): number;
+/** When this client saw the turn `key` settle, if it watched it do so. */
+export declare function observedTurnEndMs(key: string): number | null;
+export declare function resetFirstSeenForTests(): void;

package/dist/chat/super-grouping/turn-timing.js

@@ -0,0 +1,110 @@
+import { MESSAGE_CREATED_AT_KEY, parseMessageTime } from "../message-time.js";
+import { ATHENA_RUN_MARKER_KEY } from "../../agent-runtime/src/messages.js";
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readInstantMs(value) {
+  var _a;
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return value > 1e12 ? value : value * 1e3;
+  }
+  return ((_a = parseMessageTime(value)) == null ? void 0 : _a.getTime()) ?? null;
+}
+function sourceMetadata(message) {
+  var _a;
+  const kwargs = record((_a = record(message)) == null ? void 0 : _a.additional_kwargs);
+  return record(kwargs == null ? void 0 : kwargs.metadata) ?? kwargs;
+}
+function isRunMarker(message) {
+  var _a, _b;
+  return typeof ((_b = record((_a = record(message)) == null ? void 0 : _a.additional_kwargs)) == null ? void 0 : _b[ATHENA_RUN_MARKER_KEY]) === "string";
+}
+function readTurnTiming({ promptCreatedAt, custom, sourceMessages }) {
+  let endMs = null;
+  let firstStampMs = null;
+  let serverStartMs = null;
+  let serverDurationMs = null;
+  let afterMarker = false;
+  let continuedAtMs = null;
+  for (const message of sourceMessages) {
+    if (isRunMarker(message)) {
+      afterMarker = true;
+      continuedAtMs = null;
+      serverDurationMs = null;
+      continue;
+    }
+    const metadata = sourceMetadata(message);
+    const stamp = readInstantMs(metadata == null ? void 0 : metadata[MESSAGE_CREATED_AT_KEY]);
+    if (stamp !== null) {
+      firstStampMs ?? (firstStampMs = stamp);
+      if (afterMarker) continuedAtMs ?? (continuedAtMs = stamp);
+      endMs = endMs === null ? stamp : Math.max(endMs, stamp);
+    }
+    const duration = metadata == null ? void 0 : metadata.agent_duration_seconds;
+    if (typeof duration === "number" && Number.isFinite(duration) && duration > 0) {
+      serverDurationMs = duration * 1e3;
+      serverStartMs = readInstantMs(metadata == null ? void 0 : metadata.agent_start_time) ?? serverStartMs;
+    }
+  }
+  if (serverStartMs !== null && serverDurationMs !== null) {
+    const serverEnd = serverStartMs + serverDurationMs;
+    endMs = endMs === null ? serverEnd : Math.max(endMs, serverEnd);
+  }
+  const startMs = continuedAtMs ?? readInstantMs(promptCreatedAt) ?? serverStartMs ?? readInstantMs(custom == null ? void 0 : custom.agent_start_time) ?? readInstantMs(custom == null ? void 0 : custom.run_started_at) ?? readInstantMs(custom == null ? void 0 : custom[MESSAGE_CREATED_AT_KEY]) ?? firstStampMs;
+  return { startMs, endMs, serverDurationMs };
+}
+function workedDurationMs({ startMs, endMs, serverDurationMs }, observedEndMs = null) {
+  const observed = observedEndMs !== null && (endMs === null || observedEndMs - endMs <= MAX_OBSERVED_END_LAG_MS) ? observedEndMs : null;
+  const end = serverDurationMs !== null || observed === null ? endMs : endMs === null ? observed : Math.max(endMs, observed);
+  if (startMs !== null && end !== null && end >= startMs) {
+    return Math.max(end - startMs, serverDurationMs ?? 0);
+  }
+  return serverDurationMs;
+}
+const MAX_OBSERVED_END_LAG_MS = 10 * 60 * 1e3;
+function formatWorkDuration(ms) {
+  const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  if (totalMinutes < 60) return `${totalMinutes}m ${String(totalSeconds % 60).padStart(2, "0")}s`;
+  const hours = Math.floor(totalMinutes / 60);
+  return `${hours}h ${String(totalMinutes % 60).padStart(2, "0")}m`;
+}
+function workingLabel(elapsedMs) {
+  return elapsedMs < 1e3 ? "Working" : `Working for ${formatWorkDuration(elapsedMs)}`;
+}
+const MAX_FIRST_SEEN = 200;
+const firstSeen = /* @__PURE__ */ new Map();
+function firstSeenMs(key, now = Date.now()) {
+  const seen = firstSeen.get(key);
+  if (seen !== void 0) return seen;
+  firstSeen.set(key, now);
+  if (firstSeen.size > MAX_FIRST_SEEN) {
+    const oldest = firstSeen.keys().next().value;
+    if (oldest !== void 0) firstSeen.delete(oldest);
+  }
+  return now;
+}
+const observedEnds = /* @__PURE__ */ new Map();
+function recordObservedTurnEnd(key, now = Date.now()) {
+  observedEnds.set(key, now);
+  if (observedEnds.size > MAX_FIRST_SEEN) {
+    const oldest = observedEnds.keys().next().value;
+    if (oldest !== void 0) observedEnds.delete(oldest);
+  }
+  return now;
+}
+function observedTurnEndMs(key) {
+  return observedEnds.get(key) ?? null;
+}
+export {
+  firstSeenMs,
+  formatWorkDuration,
+  observedTurnEndMs,
+  readInstantMs,
+  readTurnTiming,
+  recordObservedTurnEnd,
+  workedDurationMs,
+  workingLabel
+};
+//# sourceMappingURL=turn-timing.js.map

package/dist/chat/super-grouping/turn-timing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-timing.js","sources":["../../../src/chat/super-grouping/turn-timing.ts"],"sourcesContent":["/**\n * How long an assistant turn has been working, or worked — the grouped\n * transcript's \"Working for 1m 12s\" / \"Worked for 2m 30s\" header.\n *\n * Every clock here is a server stamp the runtime already writes: `_created_at`\n * on each message (`additional_kwargs.metadata`, surfaced as\n * `metadata.custom`), and on the turn's final assistant message the\n * turn-timing middleware's `agent_start_time` / `agent_duration_seconds`\n * (epoch seconds). The converter joins only the first assistant message's\n * metadata into the turn, so the end of the turn is read off the raw messages\n * bound to it. assistant-ui's own `createdAt` is when this client first saw the\n * message, so it is never used.\n */\nimport { ATHENA_RUN_MARKER_KEY } from '@athenaintel/agent-runtime';\nimport { MESSAGE_CREATED_AT_KEY, parseMessageTime } from '../message-time';\n\nexport interface TurnTiming {\n  /**\n   * When the turn started: the prompt's stamp, else the run's own start\n   * stamps. A turn that was stopped and then continued starts at its\n   * continuation, so the clock never counts the time it sat stopped.\n   */\n  startMs: number | null;\n  /** When the turn's last message was written, from the server's stamps. */\n  endMs: number | null;\n  /** The turn-timing middleware's duration, when the final message carries it. */\n  serverDurationMs: number | null;\n}\n\nexport interface TurnTimingSources {\n  /** `_created_at` of the user message this turn answers. */\n  promptCreatedAt: string | null | undefined;\n  /** The turn's joined `metadata.custom` (its first assistant message's). */\n  custom: Record<string, unknown> | undefined;\n  /** The raw messages bound to the turn (`getExternalStoreMessages`), oldest first. */\n  sourceMessages: readonly unknown[];\n}\n\nfunction record(value: unknown): Record<string, unknown> | undefined {\n  return value && typeof value === 'object' && !Array.isArray(value)\n    ? (value as Record<string, unknown>)\n    : undefined;\n}\n\n/** An instant from an ISO stamp or epoch seconds (milliseconds past 1e12), else `null`. */\nexport function readInstantMs(value: unknown): number | null {\n  if (typeof value === 'number' && Number.isFinite(value) && value > 0) {\n    return value > 1e12 ? value : value * 1000;\n  }\n  return parseMessageTime(value)?.getTime() ?? null;\n}\n\nfunction sourceMetadata(message: unknown): Record<string, unknown> | undefined {\n  const kwargs = record(record(message)?.additional_kwargs);\n  return record(kwargs?.metadata) ?? kwargs;\n}\n\nfunction isRunMarker(message: unknown): boolean {\n  return typeof record(record(message)?.additional_kwargs)?.[ATHENA_RUN_MARKER_KEY] === 'string';\n}\n\n/** The turn's start, end and server-measured duration from the stamps it carries. */\nexport function readTurnTiming({ promptCreatedAt, custom, sourceMessages }: TurnTimingSources): TurnTiming {\n  let endMs: number | null = null;\n  let firstStampMs: number | null = null;\n  let serverStartMs: number | null = null;\n  let serverDurationMs: number | null = null;\n  let afterMarker = false;\n  let continuedAtMs: number | null = null;\n  for (const message of sourceMessages) {\n    if (isRunMarker(message)) {\n      afterMarker = true;\n      continuedAtMs = null;\n      serverDurationMs = null;\n      continue;\n    }\n    const metadata = sourceMetadata(message);\n    const stamp = readInstantMs(metadata?.[MESSAGE_CREATED_AT_KEY]);\n    if (stamp !== null) {\n      firstStampMs ??= stamp;\n      if (afterMarker) continuedAtMs ??= stamp;\n      endMs = endMs === null ? stamp : Math.max(endMs, stamp);\n    }\n    const duration = metadata?.agent_duration_seconds;\n    if (typeof duration === 'number' && Number.isFinite(duration) && duration > 0) {\n      serverDurationMs = duration * 1000;\n      serverStartMs = readInstantMs(metadata?.agent_start_time) ?? serverStartMs;\n    }\n  }\n  if (serverStartMs !== null && serverDurationMs !== null) {\n    const serverEnd = serverStartMs + serverDurationMs;\n    endMs = endMs === null ? serverEnd : Math.max(endMs, serverEnd);\n  }\n  // Without a prompt stamp the run's own server clock comes before any\n  // assistant stamp: the first assistant message is written after the turn\n  // has already been working (thinking, the first tool), so starting there\n  // would drop that time.\n  const startMs =\n    continuedAtMs ??\n    readInstantMs(promptCreatedAt) ??\n    serverStartMs ??\n    readInstantMs(custom?.agent_start_time) ??\n    readInstantMs(custom?.run_started_at) ??\n    readInstantMs(custom?.[MESSAGE_CREATED_AT_KEY]) ??\n    firstStampMs;\n  return { startMs, endMs, serverDurationMs };\n}\n\n/**\n * How long a finished turn worked: from its start to its end, else the\n * server-measured duration, else `null` (nothing truthful to show).\n *\n * The end is the server's own turn clock when the final message carries it.\n * The turn-timing stamp lands on that message only after it has streamed, so a\n * turn watched live can settle before the stamp reaches this client; the last\n * message's `_created_at` is then the start of the final answer, not its end,\n * and `observedEndMs` (when this client saw the turn settle) stands in for it.\n */\nexport function workedDurationMs(\n  { startMs, endMs, serverDurationMs }: TurnTiming,\n  observedEndMs: number | null = null,\n): number | null {\n  // A settle seen long after the last stamp is not this turn's end (a thread\n  // opened while its status was still catching up), so it is ignored.\n  const observed =\n    observedEndMs !== null && (endMs === null || observedEndMs - endMs <= MAX_OBSERVED_END_LAG_MS)\n      ? observedEndMs\n      : null;\n  const end =\n    serverDurationMs !== null || observed === null\n      ? endMs\n      : endMs === null\n        ? observed\n        : Math.max(endMs, observed);\n  // The server's own duration is a floor: a start read off a later stamp\n  // never shortens the turn below what the server measured.\n  if (startMs !== null && end !== null && end >= startMs) {\n    return Math.max(end - startMs, serverDurationMs ?? 0);\n  }\n  return serverDurationMs;\n}\n\n/** How far past its last stamp a turn may be seen to settle and still count as its end. */\nconst MAX_OBSERVED_END_LAG_MS = 10 * 60 * 1000;\n\n/** \"45s\", \"1m 12s\", \"1h 03m\". */\nexport function formatWorkDuration(ms: number): string {\n  const totalSeconds = Math.max(0, Math.floor(ms / 1000));\n  if (totalSeconds < 60) return `${totalSeconds}s`;\n  const totalMinutes = Math.floor(totalSeconds / 60);\n  if (totalMinutes < 60) return `${totalMinutes}m ${String(totalSeconds % 60).padStart(2, '0')}s`;\n  const hours = Math.floor(totalMinutes / 60);\n  return `${hours}h ${String(totalMinutes % 60).padStart(2, '0')}m`;\n}\n\n/** The live header: \"Working\" for the first second, then \"Working for 1m 12s\". */\nexport function workingLabel(elapsedMs: number): string {\n  return elapsedMs < 1000 ? 'Working' : `Working for ${formatWorkDuration(elapsedMs)}`;\n}\n\n/** The settled header: \"Worked for 2m 30s\", or `null` when the turn carries no usable stamps. */\nexport function workedLabel(timing: TurnTiming): string | null {\n  const worked = workedDurationMs(timing);\n  return worked === null ? null : `Worked for ${formatWorkDuration(worked)}`;\n}\n\nconst MAX_FIRST_SEEN = 200;\nconst firstSeen = new Map<string, number>();\n\n/**\n * The first time this client saw a turn, for a live clock with no server stamp\n * to anchor on yet (an optimistic prompt before the server echoes it). Keyed\n * per turn, so a later turn never inherits an earlier one's start; bounded.\n */\nexport function firstSeenMs(key: string, now = Date.now()): number {\n  const seen = firstSeen.get(key);\n  if (seen !== undefined) return seen;\n  firstSeen.set(key, now);\n  if (firstSeen.size > MAX_FIRST_SEEN) {\n    const oldest = firstSeen.keys().next().value;\n    if (oldest !== undefined) firstSeen.delete(oldest);\n  }\n  return now;\n}\n\nconst observedEnds = new Map<string, number>();\n\n/** Record that this client saw the turn `key` settle at `now`; returns the recorded instant. */\nexport function recordObservedTurnEnd(key: string, now = Date.now()): number {\n  observedEnds.set(key, now);\n  if (observedEnds.size > MAX_FIRST_SEEN) {\n    const oldest = observedEnds.keys().next().value;\n    if (oldest !== undefined) observedEnds.delete(oldest);\n  }\n  return now;\n}\n\n/** When this client saw the turn `key` settle, if it watched it do so. */\nexport function observedTurnEndMs(key: string): number | null {\n  return observedEnds.get(key) ?? null;\n}\n\nexport function resetFirstSeenForTests(): void {\n  firstSeen.clear();\n  observedEnds.clear();\n}\n"],"names":[],"mappings":"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"}

package/dist/chat/tiptap-text.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const jsxRuntime = require("react/jsx-runtime");
 const chatMessageBody = require("../chat-ui/rich-text/chat-message-body.cjs");
-const streamingMarkdown = require("../packages/agent-runtime/src/streaming-markdown.cjs");
+const streamingMarkdown = require("../agent-runtime/src/streaming-markdown.cjs");
 const TiptapText = ({ text, status }) => {
   const isRunning = (status == null ? void 0 : status.type) === "running";
   return /* @__PURE__ */ jsxRuntime.jsx(

package/dist/chat/tiptap-text.js

@@ -1,6 +1,6 @@
 import { jsx } from "react/jsx-runtime";
 import { ChatMessageBody } from "../chat-ui/rich-text/chat-message-body.js";
-import { hideUnterminatedMarkdownLink } from "../packages/agent-runtime/src/streaming-markdown.js";
+import { hideUnterminatedMarkdownLink } from "../agent-runtime/src/streaming-markdown.js";
 const TiptapText = ({ text, status }) => {
   const isRunning = (status == null ? void 0 : status.type) === "running";
   return /* @__PURE__ */ jsx(

package/dist/chat/use-athena-run-live.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const react = require("@assistant-ui/react");
-const threadStatus = require("../packages/agent-runtime/src/thread-status.cjs");
+const threadStatus = require("../agent-runtime/src/thread-status.cjs");
 function useAthenaRunLive() {
   const connection = threadStatus.useDeepAgentConnection();
   return react.useAuiState((s) => threadStatus.readRunLive(s.thread, connection));

package/dist/chat/use-athena-run-live.js

@@ -1,5 +1,5 @@
 import { useAuiState } from "@assistant-ui/react";
-import { useDeepAgentConnection, readRunLive } from "../packages/agent-runtime/src/thread-status.js";
+import { useDeepAgentConnection, readRunLive } from "../agent-runtime/src/thread-status.js";
 function useAthenaRunLive() {
   const connection = useDeepAgentConnection();
   return useAuiState((s) => readRunLive(s.thread, connection));

package/dist/chat/use-statewire-approval-request.cjs

@@ -3,8 +3,46 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const reactStatewire = require("@assistant-ui/react-statewire");
 const react = require("react");
 const useAthenaRunLive = require("./use-athena-run-live.cjs");
-const interrupts = require("../packages/agent-runtime/src/interrupts.cjs");
+const interrupts = require("../agent-runtime/src/interrupts.cjs");
 const NO_QUEUED_LANE_DECISIONS = Object.freeze({});
+const NO_ACTION_REQUESTS = [];
+const answeredRequests = /* @__PURE__ */ new Map();
+const answeredListeners = /* @__PURE__ */ new Set();
+let answeredVersion = 0;
+function notifyAnswered() {
+  answeredVersion += 1;
+  for (const listener of answeredListeners) listener();
+}
+function recordAnswered(requestId, laneIds) {
+  answeredRequests.set(requestId, laneIds);
+  notifyAnswered();
+}
+function forgetAnswered(requestId) {
+  if (answeredRequests.delete(requestId)) notifyAnswered();
+}
+function subscribeAnswered(listener) {
+  answeredListeners.add(listener);
+  return () => {
+    answeredListeners.delete(listener);
+  };
+}
+const readAnsweredVersion = () => answeredVersion;
+function answeredLaneIds(value, actionRequests) {
+  const ids = interrupts.laneInterruptIds(actionRequests) ?? [];
+  if (typeof value === "object" && value !== null && "lane_decisions" in value) {
+    const lanes = value.lane_decisions;
+    if (typeof lanes === "object" && lanes !== null) {
+      for (const id of Object.keys(lanes)) if (!ids.includes(id)) ids.push(id);
+    }
+  }
+  return ids;
+}
+function mirrorAlreadyAnswered(answeredLanes, liveActionRequests) {
+  if (answeredLanes === void 0) return false;
+  const ids = interrupts.laneInterruptIds(liveActionRequests);
+  if (ids === null) return false;
+  return ids.every((id) => answeredLanes.includes(id));
+}
 function useStatewireApprovalRequest(options = {}) {
   var _a;
   const {
@@ -22,10 +60,32 @@ function useStatewireApprovalRequest(options = {}) {
   const actionRequests = react.useMemo(() => interrupts.pendingActionRequests(hitl), [hitl]);
   const isRunning = useAthenaRunLive.useAthenaRunLive();
   const mirror = reactStatewire.useStatewireState(interrupts.readInterruptMirror);
-  const liveHitl = request === void 0 && isRunning ? interrupts.asHitlApproval(interrupts.interruptMirrorPayload(mirror)) : null;
-  const liveActionRequests = react.useMemo(() => interrupts.pendingActionRequests(liveHitl), [liveHitl]);
+  const mirrorHitl = request === void 0 && isRunning ? interrupts.asHitlApproval(interrupts.interruptMirrorPayload(mirror)) : null;
+  const mirrorActionRequests = react.useMemo(() => interrupts.pendingActionRequests(mirrorHitl), [mirrorHitl]);
+  const lastRequestIdRef = react.useRef(void 0);
+  if (requestId !== void 0) lastRequestIdRef.current = requestId;
+  react.useSyncExternalStore(subscribeAnswered, readAnsweredVersion, readAnsweredVersion);
+  const answeredLanes = lastRequestIdRef.current === void 0 ? void 0 : answeredRequests.get(lastRequestIdRef.current);
+  const mirrorCleared = interrupts.interruptMirrorPayload(mirror) === void 0;
+  react.useEffect(() => {
+    if (requestId === void 0) return;
+    return () => {
+      if (lastRequestIdRef.current !== requestId) forgetAnswered(requestId);
+    };
+  }, [requestId]);
+  react.useEffect(() => {
+    if (mirrorCleared && lastRequestIdRef.current !== void 0) forgetAnswered(lastRequestIdRef.current);
+  }, [mirrorCleared]);
+  react.useEffect(
+    () => () => {
+      if (lastRequestIdRef.current !== void 0) forgetAnswered(lastRequestIdRef.current);
+    },
+    []
+  );
+  const liveHitl = mirrorAlreadyAnswered(answeredLanes, mirrorActionRequests) ? null : mirrorHitl;
+  const liveActionRequests = liveHitl === mirrorHitl ? mirrorActionRequests : NO_ACTION_REQUESTS;
   const queuedLaneDecisions = reactStatewire.useStatewireState(interrupts.readQueuedLaneDecisions) ?? NO_QUEUED_LANE_DECISIONS;
-  const { pending, resume } = interrupts.useApprovalResumeLock({
+  const { pending, resume: resumeLocked } = interrupts.useApprovalResumeLock({
     requestId,
     isRunning,
     pendingResumeGraceMs,
@@ -39,6 +99,15 @@ function useStatewireApprovalRequest(options = {}) {
       response: { type: "resume", value }
     })
   });
+  const resume = react.useCallback(
+    (value) => {
+      if (requestId !== void 0) {
+        recordAnswered(requestId, answeredLaneIds(value, actionRequests));
+      }
+      return resumeLocked(value);
+    },
+    [requestId, actionRequests, resumeLocked]
+  );
   const sendLaneDecisions = react.useCallback(
     (lanes) => requestId !== void 0 ? resume({ lane_decisions: lanes }) : sendCommand({ type: "run/lane-input", laneDecisions: lanes }),
     [requestId, resume, sendCommand]