@yaklabs-ai/plugin-sdk 0.13.6 → 0.13.8

package/dist/transcript-review.js

@@ -0,0 +1,680 @@
+// packages/time/dist/temporal.js
+import { Temporal as Polyfill } from "@js-temporal/polyfill";
+var engineTemporal = Reflect.get(globalThis, "Temporal");
+var Temporal = engineTemporal ?? Polyfill;
+
+// packages/plugin-protocol/dist/transcript.js
+import { z } from "zod";
+var WorkBlockCoverageSchema = z.strictObject({
+  firstToolResultEntryId: z.string().min(1),
+  lastToolResultEntryId: z.string().min(1),
+  toolResultEntryIds: z.array(z.string().min(1)).min(1).max(4096)
+}).refine((value) => value.firstToolResultEntryId === value.toolResultEntryIds[0] && value.lastToolResultEntryId === value.toolResultEntryIds.at(-1) && new Set(value.toolResultEntryIds).size === value.toolResultEntryIds.length);
+var RUN_STARTED_CUSTOM_TYPE = "session_run_started";
+var RUN_TERMINAL_CUSTOM_TYPE = "session_run_state";
+
+// packages/plugin-protocol/dist/transcript-review.js
+var RUN_INPUT_CUSTOM_TYPE = "session_run_input";
+var HUMAN_INPUT_CAUSES = /* @__PURE__ */ new Set([
+  "human_send",
+  "human_resume",
+  "queued_human"
+]);
+var TASK_CONTEXT_TYPES = /* @__PURE__ */ new Set([
+  "subagent_result",
+  "collaboration_message",
+  "background_task_result",
+  "ui_action",
+  "user_pasted_content",
+  "message_draft_sent",
+  "daemon_service_turn"
+]);
+var SYSTEM_PROMPT_CUSTOM_TYPES = /* @__PURE__ */ new Set([
+  "resolved_prompt",
+  "composition_snapshot",
+  "system_prompt_delta"
+]);
+var ATTEMPT_SUBJECT_MAX_CHARS = 2e3;
+var SHELL_TOOL_NAMES = /* @__PURE__ */ new Set(["bash", "shell"]);
+var RUN_MARKER_TYPES = /* @__PURE__ */ new Set([
+  RUN_STARTED_CUSTOM_TYPE,
+  RUN_INPUT_CUSTOM_TYPE,
+  RUN_TERMINAL_CUSTOM_TYPE
+]);
+function isObj(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function str(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function num(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function reviewInstantMs(value) {
+  const asNumber = num(value);
+  if (asNumber !== void 0)
+    return asNumber;
+  const text = str(value);
+  if (text === void 0)
+    return void 0;
+  try {
+    return Temporal.Instant.from(text).epochMilliseconds;
+  } catch {
+    return void 0;
+  }
+}
+function formatReviewInstant(ms) {
+  return Temporal.Instant.fromEpochMilliseconds(ms).toString({
+    fractionalSecondDigits: 3
+  });
+}
+var instantMs = reviewInstantMs;
+function messageOf(entry) {
+  return entry.type === "message" && isObj(entry.message) ? entry.message : void 0;
+}
+function reviewContentBlocks(content) {
+  if (typeof content === "string")
+    return [{ type: "text", text: content }];
+  return Array.isArray(content) ? content.filter(isObj) : [];
+}
+function reviewContentText(content) {
+  return reviewContentBlocks(content).filter((block) => block.type === "text").map((block) => str(block.text) ?? "").join("\n");
+}
+function isHumanVerifiedMessage(message) {
+  return isObj(message) && message.role === "user" && typeof message.clientIntentId === "string" && isObj(message.details) && typeof message.details.deliveryId === "string";
+}
+function reviewContextOf(entry) {
+  if (!isObj(entry))
+    return void 0;
+  const message = messageOf(entry);
+  const source = message?.role === "custom" ? message : entry.type === "custom_message" ? entry : void 0;
+  if (source === void 0)
+    return void 0;
+  const customType = str(source.customType);
+  return {
+    ...customType === void 0 ? {} : { customType },
+    ...isObj(source.details) ? { details: source.details } : {},
+    content: source.content
+  };
+}
+var ROLE_CLASS = {
+  assistant: "assistant",
+  toolResult: "tool_result",
+  system: "system"
+};
+var ROLE_KIND = {
+  user: "user",
+  assistant: "assistant",
+  toolResult: "tool_result"
+};
+function describeReviewEntry(entry) {
+  if (!isObj(entry))
+    return { kind: "unreadable", recordClass: "unreadable" };
+  const entryId = str(entry.id);
+  const base = entryId === void 0 ? {} : { entryId };
+  const entryMs = instantMs(entry.timestamp);
+  const message = messageOf(entry);
+  if (message !== void 0) {
+    const role = str(message.role);
+    const timestampMs = instantMs(message.timestamp) ?? entryMs;
+    const time2 = timestampMs === void 0 ? {} : { timestampMs };
+    if (role === "custom") {
+      const context = reviewContextOf(entry);
+      const customType = context?.customType;
+      const clientIntentId = str(context?.details?.clientIntentId);
+      return {
+        ...base,
+        kind: `custom_message:${customType ?? ""}`,
+        recordClass: "context",
+        ...customType === void 0 ? {} : { customType },
+        ...time2,
+        ...clientIntentId === void 0 ? {} : { clientIntentId }
+      };
+    }
+    if (role === "user") {
+      const clientIntentId = isHumanVerifiedMessage(message) ? str(message.clientIntentId) : void 0;
+      return {
+        ...base,
+        kind: "user",
+        recordClass: clientIntentId === void 0 ? "user" : "human",
+        ...time2,
+        ...clientIntentId === void 0 ? {} : { clientIntentId }
+      };
+    }
+    return {
+      ...base,
+      kind: (role === void 0 ? void 0 : ROLE_KIND[role]) ?? "other",
+      recordClass: (role === void 0 ? void 0 : ROLE_CLASS[role]) ?? "other",
+      ...time2
+    };
+  }
+  const time = entryMs === void 0 ? {} : { timestampMs: entryMs };
+  switch (entry.type) {
+    case "custom": {
+      const customType = str(entry.customType) ?? "";
+      const data = isObj(entry.data) ? entry.data : {};
+      const markerMs = entryMs ?? num(data.acceptedAtMs) ?? num(data.runStartedAt) ?? num(data.at) ?? num(data.observedAt);
+      return {
+        ...base,
+        kind: `custom:${customType}`,
+        recordClass: RUN_MARKER_TYPES.has(customType) ? "run_marker" : "custom",
+        customType,
+        ...markerMs === void 0 ? {} : { timestampMs: markerMs }
+      };
+    }
+    case "custom_message": {
+      const context = reviewContextOf(entry);
+      const clientIntentId = str(context?.details?.clientIntentId);
+      return {
+        ...base,
+        kind: `custom_message:${context?.customType ?? ""}`,
+        recordClass: "context",
+        ...context?.customType === void 0 ? {} : { customType: context.customType },
+        ...time,
+        ...clientIntentId === void 0 ? {} : { clientIntentId }
+      };
+    }
+    case "compaction":
+      return {
+        ...base,
+        kind: "compaction",
+        recordClass: "compaction",
+        ...time
+      };
+    case "branch_summary":
+      return {
+        ...base,
+        kind: "branch_summary",
+        recordClass: "branch_summary",
+        ...time
+      };
+    default:
+      return { ...base, kind: "other", recordClass: "other", ...time };
+  }
+}
+var SHELL_HEADER_RE = /^(exit_code|duration|stdout|stderr):/;
+var ANSI_RE = new RegExp([
+  "\\u001b\\[[0-?]*[ -/]*[@-~]",
+  "\\u001b\\][^\\u0007\\u001b]*(?:\\u0007|\\u001b\\\\)",
+  "\\u001b[@-Z\\\\-_]",
+  "\\[[0-9;]*m"
+].join("|"), "g");
+var WRAPPER_LINE_RE = /^<\/?[A-Za-z][\w.-]*>$/;
+var ERROR_PREFIX = "[error] ";
+function errorLineText(line) {
+  const text = line.replace(ANSI_RE, "").trim();
+  if (text === "" || WRAPPER_LINE_RE.test(text))
+    return void 0;
+  const bare = text.startsWith(ERROR_PREFIX) ? text.slice(ERROR_PREFIX.length).trim() : text;
+  return bare === "" ? void 0 : bare;
+}
+function firstErrorLine(text) {
+  const lines = text.split(/\r?\n/);
+  const stderrAt = lines.findIndex((line) => line.replace(ANSI_RE, "").trim().startsWith("stderr:"));
+  if (stderrAt >= 0) {
+    const sameLine = errorLineText(lines[stderrAt].replace(ANSI_RE, "").trim().slice("stderr:".length));
+    if (sameLine !== void 0)
+      return sameLine;
+    for (const line of lines.slice(stderrAt + 1)) {
+      const found = errorLineText(line);
+      if (found !== void 0)
+        return found;
+    }
+  }
+  for (const line of lines) {
+    const found = errorLineText(line);
+    if (found !== void 0 && !SHELL_HEADER_RE.test(found))
+      return found;
+  }
+  return void 0;
+}
+var URI_VALUE_RE = /^[A-Za-z][A-Za-z0-9+.-]*:\/\//;
+function collectUris(value, into, depth = 0) {
+  if (depth > 8)
+    return;
+  if (typeof value === "string") {
+    if (URI_VALUE_RE.test(value))
+      into.push(value);
+  } else if (Array.isArray(value)) {
+    for (const item of value)
+      collectUris(item, into, depth + 1);
+  } else if (isObj(value)) {
+    for (const item of Object.values(value))
+      collectUris(item, into, depth + 1);
+  }
+}
+function subjectOf(tool, args) {
+  if (!isObj(args))
+    return void 0;
+  if (SHELL_TOOL_NAMES.has(tool) && typeof args.command === "string") {
+    return args.command;
+  }
+  return str(args.path) ?? str(args.uri) ?? str(args.url) ?? str(args.command);
+}
+function createTranscriptReview(options = {}) {
+  const untilMs = options.untilMs;
+  const records = [];
+  const byPosition = /* @__PURE__ */ new Map();
+  const byEntryId = /* @__PURE__ */ new Map();
+  const rawInputs = [];
+  const runs = /* @__PURE__ */ new Map();
+  const runOrder = [];
+  const humanByIntent = /* @__PURE__ */ new Map();
+  const contextByIntent = /* @__PURE__ */ new Map();
+  const attempts = [];
+  const attemptByBlock = /* @__PURE__ */ new Map();
+  const attemptsByPosition = /* @__PURE__ */ new Map();
+  const results = [];
+  const resultByPosition = /* @__PURE__ */ new Map();
+  const open = /* @__PURE__ */ new Map();
+  const answered = /* @__PURE__ */ new Map();
+  let cutAt;
+  let finished;
+  const runFor = (runId) => {
+    let run = runs.get(runId);
+    if (run === void 0) {
+      run = { runId };
+      runs.set(runId, run);
+      runOrder.push(runId);
+    }
+    return run;
+  };
+  const addResult = (position, entryId, message) => {
+    const toolCallId = str(message.toolCallId);
+    const details = isObj(message.details) ? message.details : {};
+    const isError = message.isError === true;
+    const exitCode = num(details.exitCode);
+    const timedOut = details.timedOut === true;
+    const failed = isError || exitCode !== void 0 && exitCode !== 0 || timedOut;
+    let pairing;
+    let attempt;
+    let candidates = [];
+    if (toolCallId === void 0) {
+      pairing = "no-id";
+    } else {
+      const stillOpen = open.get(toolCallId) ?? [];
+      if (stillOpen.length === 1) {
+        attempt = stillOpen.pop();
+        attempts[attempt].result = position;
+        const done = answered.get(toolCallId) ?? [];
+        done.push(attempt);
+        answered.set(toolCallId, done);
+        pairing = "paired";
+      } else if (stillOpen.length > 1) {
+        pairing = "ambiguous";
+        candidates = [...stillOpen];
+        for (const index of stillOpen) {
+          attempts[index].ambiguousResults.push(position);
+        }
+      } else if ((answered.get(toolCallId) ?? []).length > 0) {
+        attempt = answered.get(toolCallId).at(-1);
+        attempts[attempt].extraResults.push(position);
+        pairing = "extra";
+      } else {
+        pairing = "orphan";
+      }
+    }
+    const errorLine = failed ? firstErrorLine(reviewContentText(message.content)) : void 0;
+    const tool = str(message.toolName);
+    resultByPosition.set(position, results.length);
+    results.push({
+      position,
+      ...entryId === void 0 ? {} : { entryId },
+      ...toolCallId === void 0 ? {} : { toolCallId },
+      ...tool === void 0 ? {} : { tool },
+      pairing,
+      ...attempt === void 0 ? {} : { attempt },
+      candidates,
+      isError,
+      ...exitCode === void 0 ? {} : { exitCode },
+      timedOut,
+      failed,
+      ...errorLine === void 0 ? {} : { firstErrorLine: errorLine }
+    });
+  };
+  const add = (input) => {
+    if (finished !== void 0) {
+      throw new Error("createTranscriptReview: add() after finish()");
+    }
+    if (cutAt !== void 0)
+      return "stop";
+    const description = describeReviewEntry(input.entry);
+    if (untilMs !== void 0 && description.timestampMs !== void 0 && description.timestampMs >= untilMs) {
+      cutAt = {
+        position: input.position,
+        ...description.entryId === void 0 ? {} : { entryId: description.entryId },
+        timestampMs: description.timestampMs
+      };
+      return "stop";
+    }
+    const position = input.position;
+    const entry = isObj(input.entry) ? input.entry : void 0;
+    const message = entry === void 0 ? void 0 : messageOf(entry);
+    const hasProse = description.recordClass === "assistant" && reviewContentText(message?.content).trim() !== "";
+    byPosition.set(position, records.length);
+    if (description.entryId !== void 0) {
+      byEntryId.set(description.entryId, records.length);
+    }
+    records.push({
+      ...description,
+      position,
+      ...input.messageLine === void 0 ? {} : { messageLine: input.messageLine },
+      hasProse
+    });
+    switch (description.recordClass) {
+      case "run_marker": {
+        const data = isObj(entry?.data) ? entry.data : {};
+        const runId = str(data.runId);
+        if (description.customType === RUN_INPUT_CUSTOM_TYPE) {
+          const cause = str(data.inputCause);
+          const channel = str(data.channel);
+          const inputId = str(data.inputId);
+          const acceptedAtMs = num(data.acceptedAtMs);
+          const runInput = {
+            position,
+            ...description.entryId === void 0 ? {} : { entryId: description.entryId },
+            ...runId === void 0 ? {} : { runId },
+            ...channel === void 0 ? {} : { channel },
+            ...cause === void 0 ? {} : { cause },
+            ...inputId === void 0 ? {} : { inputId },
+            ...acceptedAtMs === void 0 ? {} : { acceptedAtMs },
+            human: cause !== void 0 && HUMAN_INPUT_CAUSES.has(cause)
+          };
+          rawInputs.push(runInput);
+          if (runId !== void 0) {
+            const run = runFor(runId);
+            run.firstInput ??= { ...runInput, opensRun: true };
+          }
+        } else if (runId !== void 0) {
+          const run = runFor(runId);
+          if (description.customType === RUN_STARTED_CUSTOM_TYPE) {
+            run.startedPosition ??= position;
+          } else {
+            const state = str(data.runState);
+            run.firstStatePosition ??= position;
+            run.lastState = {
+              position,
+              ...state === void 0 ? {} : { state }
+            };
+          }
+        }
+        break;
+      }
+      case "human":
+        if (description.clientIntentId !== void 0 && !humanByIntent.has(description.clientIntentId)) {
+          humanByIntent.set(description.clientIntentId, position);
+        }
+        break;
+      case "context":
+        if (description.clientIntentId !== void 0 && description.customType !== void 0 && TASK_CONTEXT_TYPES.has(description.customType) && !contextByIntent.has(description.clientIntentId)) {
+          contextByIntent.set(description.clientIntentId, {
+            position,
+            customType: description.customType
+          });
+        }
+        break;
+      case "assistant":
+        reviewContentBlocks(message?.content).forEach((block, blockIndex) => {
+          if (block.type !== "toolCall")
+            return;
+          const toolCallId = str(block.id);
+          const tool = str(block.name) ?? "?";
+          const uris = [];
+          collectUris(block.arguments, uris);
+          const fullSubject = subjectOf(tool, block.arguments);
+          const subject = fullSubject === void 0 ? void 0 : fullSubject.slice(0, ATTEMPT_SUBJECT_MAX_CHARS);
+          const index = attempts.length;
+          attempts.push({
+            index,
+            position,
+            ...description.entryId === void 0 ? {} : { entryId: description.entryId },
+            block: blockIndex,
+            ...toolCallId === void 0 ? {} : { toolCallId },
+            tool,
+            ...subject === void 0 ? {} : { subject },
+            ...fullSubject !== void 0 && fullSubject.length > ATTEMPT_SUBJECT_MAX_CHARS ? { subjectLength: fullSubject.length } : {},
+            uris,
+            extraResults: [],
+            ambiguousResults: []
+          });
+          attemptByBlock.set(`${position}#${blockIndex}`, index);
+          const atPosition = attemptsByPosition.get(position) ?? [];
+          atPosition.push(index);
+          attemptsByPosition.set(position, atPosition);
+          if (toolCallId !== void 0) {
+            const list = open.get(toolCallId) ?? [];
+            list.push(index);
+            open.set(toolCallId, list);
+          }
+        });
+        break;
+      case "tool_result":
+        if (message !== void 0)
+          addResult(position, description.entryId, message);
+        break;
+      default:
+        break;
+    }
+    return "continue";
+  };
+  const finish = () => {
+    if (finished !== void 0)
+      return finished;
+    const endPosition = records.length === 0 ? cutAt?.position ?? 1 : records.at(-1).position + 1;
+    const contextByIntentPosition = contextByIntent;
+    const inputs = rawInputs.map((raw) => {
+      const run = raw.runId === void 0 ? void 0 : runs.get(raw.runId);
+      const opensRun = run?.firstInput?.position === raw.position;
+      const linkedMessage = raw.inputId === void 0 ? void 0 : humanByIntent.get(raw.inputId);
+      const linkedContext = raw.inputId === void 0 ? void 0 : contextByIntentPosition.get(raw.inputId)?.position;
+      return {
+        ...raw,
+        opensRun,
+        ...linkedMessage === void 0 ? {} : { linkedMessage },
+        ...linkedContext === void 0 ? {} : { linkedContext }
+      };
+    });
+    const inputByPosition = new Map(inputs.map((input) => [input.position, input]));
+    const inputById = /* @__PURE__ */ new Map();
+    for (const input of inputs) {
+      if (input.inputId !== void 0 && !inputById.has(input.inputId)) {
+        inputById.set(input.inputId, input);
+      }
+    }
+    const finalRuns = /* @__PURE__ */ new Map();
+    for (const runId of runOrder) {
+      const run = runs.get(runId);
+      const firstInput = run.firstInput === void 0 ? void 0 : inputByPosition.get(run.firstInput.position);
+      const boundary = Math.min(run.startedPosition ?? Number.POSITIVE_INFINITY, firstInput?.position ?? Number.POSITIVE_INFINITY, run.firstStatePosition ?? Number.POSITIVE_INFINITY);
+      finalRuns.set(runId, {
+        runId,
+        ...run.startedPosition === void 0 ? {} : { startedPosition: run.startedPosition },
+        ...firstInput === void 0 ? {} : { firstInput },
+        ...run.lastState === void 0 ? {} : { lastState: run.lastState },
+        boundary: Number.isFinite(boundary) ? boundary : endPosition
+      });
+    }
+    const hasRuns = inputs.length > 0;
+    const starts = [];
+    const openerOf = (position) => {
+      const record = records[byPosition.get(position)];
+      return {
+        position,
+        ...record.entryId === void 0 ? {} : { entryId: record.entryId },
+        ...record.recordClass === "context" && record.customType !== void 0 ? { customType: record.customType } : {}
+      };
+    };
+    if (hasRuns) {
+      for (const run of finalRuns.values()) {
+        const first = run.firstInput;
+        if (first === void 0 || !first.human)
+          continue;
+        const via = first.linkedMessage !== void 0 ? "message" : first.linkedContext !== void 0 ? "context" : "unresolved";
+        const openerPosition = first.linkedMessage ?? first.linkedContext;
+        starts.push({
+          // An opener stored before its run's markers still belongs to its span.
+          boundary: Math.min(run.boundary, openerPosition ?? Number.POSITIVE_INFINITY),
+          runId: run.runId,
+          ...openerPosition === void 0 ? {} : { opener: openerOf(openerPosition) },
+          openerVia: via,
+          firstInput: first
+        });
+      }
+    } else {
+      for (const record of records) {
+        if (record.recordClass !== "human")
+          continue;
+        starts.push({
+          boundary: record.position,
+          opener: openerOf(record.position),
+          openerVia: "fallback"
+        });
+      }
+    }
+    starts.sort((left, right) => left.boundary - right.boundary);
+    const runStarts = [...finalRuns.values()].map((run) => ({ runId: run.runId, boundary: run.boundary })).sort((left, right) => left.boundary - right.boundary);
+    const previousProse = (before) => {
+      let index = byPosition.get(before);
+      if (index === void 0)
+        return void 0;
+      for (index -= 1; index >= 0; index -= 1) {
+        if (records[index].hasProse)
+          return records[index].position;
+      }
+      return void 0;
+    };
+    const spans = starts.map((start, index) => {
+      const next = starts[index + 1];
+      const end = next?.boundary ?? endPosition;
+      const closingEnd = next?.opener !== void 0 ? Math.max(end, next.opener.position + 1) : end;
+      const ownRuns = [];
+      const closingRuns = [];
+      for (const run of runStarts) {
+        const started = finalRuns.get(run.runId).startedPosition;
+        if (started !== void 0 && started >= start.boundary && started < end) {
+          if (!ownRuns.includes(run.runId))
+            ownRuns.push(run.runId);
+        }
+      }
+      const joined = [];
+      for (const input of inputs) {
+        if (input.runId === void 0)
+          continue;
+        if (input.position >= start.boundary && input.position < end) {
+          if (!ownRuns.includes(input.runId))
+            ownRuns.push(input.runId);
+          if (input.human && !input.opensRun)
+            joined.push(input);
+        } else if (input.position >= end && input.position < closingEnd) {
+          if (!closingRuns.includes(input.runId))
+            closingRuns.push(input.runId);
+        }
+      }
+      ownRuns.sort((left, right) => finalRuns.get(left).boundary - finalRuns.get(right).boundary);
+      const close = next !== void 0 ? next.opener !== void 0 ? "next-opener" : "next-opener-unresolved" : cutAt !== void 0 ? "time-bound" : "end-of-store";
+      const previousAnswer = previousProse(start.boundary);
+      return {
+        index,
+        boundary: start.boundary,
+        end,
+        closingEnd,
+        ...start.runId === void 0 ? {} : { runId: start.runId },
+        ...start.opener === void 0 ? {} : { opener: start.opener },
+        openerVia: start.openerVia,
+        ...start.firstInput === void 0 ? {} : { firstInput: start.firstInput },
+        ownRuns,
+        closingRuns,
+        joined,
+        close,
+        ...previousAnswer === void 0 ? {} : { previousAnswer }
+      };
+    });
+    const frozenAttempts = attempts;
+    const lastAtOrBefore = (list, position) => {
+      let low = 0;
+      let high = list.length - 1;
+      let found;
+      while (low <= high) {
+        const middle = low + high >> 1;
+        if (list[middle].boundary <= position) {
+          found = list[middle];
+          low = middle + 1;
+        } else {
+          high = middle - 1;
+        }
+      }
+      return found;
+    };
+    finished = {
+      records,
+      ...cutAt === void 0 ? {} : { cutAt },
+      ...untilMs === void 0 ? {} : { untilMs },
+      inputs,
+      runs: finalRuns,
+      hasRuns,
+      spans,
+      attempts: frozenAttempts,
+      results,
+      endPosition,
+      recordAt: (position) => {
+        const index = byPosition.get(position);
+        return index === void 0 ? void 0 : records[index];
+      },
+      recordOfEntry: (entryId) => {
+        const index = byEntryId.get(entryId);
+        return index === void 0 ? void 0 : records[index];
+      },
+      spanAt: (position) => position < endPosition ? lastAtOrBefore(spans, position) : void 0,
+      runExtent: (runId) => {
+        const run = finalRuns.get(runId);
+        if (run === void 0)
+          return void 0;
+        const at = runStarts.findIndex((candidate) => candidate.runId === runId);
+        const next = runStarts.slice(at + 1).find((candidate) => candidate.boundary > run.boundary);
+        return { start: run.boundary, end: next?.boundary ?? endPosition };
+      },
+      inputById: (inputId) => inputById.get(inputId),
+      attemptAt: (position, block) => {
+        const index = attemptByBlock.get(`${position}#${block}`);
+        return index === void 0 ? void 0 : attempts[index];
+      },
+      attemptsAt: (position) => (attemptsByPosition.get(position) ?? []).map((index) => attempts[index]),
+      resultAt: (position) => {
+        const index = resultByPosition.get(position);
+        return index === void 0 ? void 0 : results[index];
+      },
+      outcome: (attempt, uptoPosition) => {
+        const resultPosition = attempt.result !== void 0 && (uptoPosition === void 0 || attempt.result <= uptoPosition) ? attempt.result : void 0;
+        if (resultPosition === void 0) {
+          return {
+            status: attempt.ambiguousResults.length > 0 ? "ambiguous" : "no-result",
+            isError: false,
+            timedOut: false
+          };
+        }
+        const result = results[resultByPosition.get(resultPosition)];
+        return {
+          status: result.failed ? "failed" : "ok",
+          isError: result.isError,
+          ...result.exitCode === void 0 ? {} : { exitCode: result.exitCode },
+          timedOut: result.timedOut,
+          resultPosition,
+          ...result.entryId === void 0 ? {} : { resultEntryId: result.entryId },
+          ...result.firstErrorLine === void 0 ? {} : { firstErrorLine: result.firstErrorLine }
+        };
+      }
+    };
+    return finished;
+  };
+  return { add, finish };
+}
+export {
+  SYSTEM_PROMPT_CUSTOM_TYPES,
+  TASK_CONTEXT_TYPES,
+  createTranscriptReview,
+  formatReviewInstant,
+  reviewContentBlocks,
+  reviewContentText,
+  reviewContextOf,
+  reviewInstantMs
+};