@yaklabs-ai/plugin-sdk 0.54.0 → 0.54.1

package/dist/canonical-transcript.js

@@ -1,12 +1,20 @@
 // packages/herd-transcript/dist/context-messages.js
+var TAB_CONTEXT_CUSTOM_TYPE = "tab_context";
 var UI_ACTION_CUSTOM_TYPE = "ui_action";
+var COMPOSER_REFERENCES_CUSTOM_TYPE = "composer_references";
 var USER_PASTED_CONTENT_CUSTOM_TYPE = "user_pasted_content";
 var ATTACHMENTS_CUSTOM_TYPE = "attachments";
 var DAEMON_SERVICE_TURN_CUSTOM_TYPE = "daemon_service_turn";
+var COLLABORATION_MESSAGE_CUSTOM_TYPE = "collaboration_message";
+var RUNTIME_NOTICE_CUSTOM_TYPE = "runtime_notice";
+var AVAILABILITY_FACTS_CUSTOM_TYPE = "availability_facts";
 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_SHELL_COMMAND_CUSTOM_TYPE = "user_shell_command";
 var USER_INVOKED_CUSTOM_TYPE = "user_invoked";
+var HEADLESS_OPERATION_CUSTOM_TYPE = "headless_operation";
+var SYSTEM_PROMPT_DELTA_CUSTOM_TYPE = "system_prompt_delta";
 
 // packages/herd-transcript/dist/turn-messages.js
 var SUBAGENT_RESULT_CUSTOM_TYPE = "subagent_result";
@@ -215,6 +223,8 @@ var coverageSchema = z2.strictObject({
 
 // packages/herd-transcript/dist/run-failure.js
 var RUN_FAILURE_DIAGNOSTIC_TYPE = "herd.run.failure";
+var RUN_FAILURE_CUSTOM_TYPE = "run_failure";
+var RUN_RECOVERY_CUSTOM_TYPE = "run_recovery";
 var runFailureCauseSchema = z3.strictObject({
   reason: z3.enum(RUN_FAILURE_REASONS),
   source: z3.enum(["assistant_message", "exception", "runtime"]),
@@ -1414,7 +1424,7 @@ 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) {
+function normalizeToolResultMessageCompletion(body, completedAt, entryId2) {
   const record = asRecord2(body);
   const toolCallId = getToolCallId(body);
   if (record === void 0 || toolCallId === void 0)
@@ -1423,7 +1433,7 @@ function normalizeToolResultMessageCompletion(body, completedAt, entryId) {
   const resultText = getResultText(record);
   return {
     toolCallId,
-    ...stringField("entryId", entryId),
+    ...stringField("entryId", entryId2),
     ...stringField("name", getToolName(record)),
     ...stringField("resultText", resultText),
     ...unknownField("resultDetails", record["details"]),
@@ -3932,10 +3942,564 @@ function contentText(content) {
 function asRecord3(value) {
   return typeof value === "object" && value !== null ? value : void 0;
 }
+
+// packages/plugin-protocol/dist/phase-shift.js
+import { z as z7 } from "zod";
+
+// packages/plugin-protocol/dist/transcript.js
+import { z as z6 } from "zod";
+var WorkBlockCoverageSchema = z6.strictObject({
+  firstToolResultEntryId: z6.string().min(1),
+  lastToolResultEntryId: z6.string().min(1),
+  toolResultEntryIds: z6.array(z6.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_TYPE2 = "session_run_state";
+
+// packages/plugin-protocol/dist/phase-shift.js
+var PHASE_SHIFT_EXTENSION_ID = "kay.phase-shift";
+var PHASE_SHIFT_ENTRY_NAME = "observation";
+var PHASE_SHIFT_CUSTOM_TYPE = `ext:${PHASE_SHIFT_EXTENSION_ID}:${PHASE_SHIFT_ENTRY_NAME}`;
+var PHASE_SHIFT_TIMELINE_CUSTOM_TYPE = `ext:${PHASE_SHIFT_EXTENSION_ID}:timeline`;
+var PHASE_SHIFT_DETECTOR_VERSION = "activity-memory-v1";
+var entryId = z7.string().min(1).max(256);
+var purpose = z7.string().trim().min(1).max(320);
+var sourceTime = z7.iso.datetime();
+var phaseShiftMemorySchema = z7.object({
+  startEntryId: entryId,
+  purpose,
+  anchors: z7.array(z7.object({ entryId, excerpt: z7.string().max(250) })).min(1).max(3)
+});
+var phaseShiftCostSchema = z7.object({
+  amountUsd: z7.number().nonnegative(),
+  amountBasis: z7.enum(["measured", "list-estimate", "unknown"]),
+  inputTokens: z7.number().int().nonnegative(),
+  outputTokens: z7.number().int().nonnegative(),
+  /**
+   * The highest provider-attempt ordinal this check accounted for; recovery
+   * after a failure makes it more than one. An attempt that threw before
+   * reporting usage is invisible to accounting, so this is a lower bound on
+   * what the provider was actually asked to do.
+   */
+  attempts: z7.number().int().positive()
+});
+var observationFields = {
+  detectorVersion: z7.literal(PHASE_SHIFT_DETECTOR_VERSION),
+  modelReference: z7.string().min(1).max(256),
+  observedAt: z7.iso.datetime(),
+  throughEntryId: entryId,
+  windowEntryIds: z7.array(entryId).min(1).max(40),
+  memory: phaseShiftMemorySchema
+};
+var changeFields = {
+  startEntryId: entryId,
+  relation: z7.enum(["outcome", "phase"]),
+  reason: z7.string().trim().min(1).max(2e3),
+  purposeAfter: purpose
+};
+var phaseShiftObservationV1Schema = z7.object({
+  version: z7.literal(1),
+  ...observationFields,
+  changes: z7.array(z7.object(changeFields)).max(39)
+});
+var phaseShiftObservationV2Schema = z7.object({
+  version: z7.literal(2),
+  ...observationFields,
+  /** Timestamp of the `windowEntryIds[0]` entry: where this check's coverage starts. */
+  windowStartAt: sourceTime,
+  /** Timestamp of the `throughEntryId` entry: where this check's coverage ends. */
+  throughAt: sourceTime,
+  /** What this check cost to run; absent on a record written before it was accounted. */
+  cost: phaseShiftCostSchema.optional(),
+  changes: z7.array(z7.object({
+    ...changeFields,
+    /** Timestamp of the `startEntryId` entry: when the new work began. */
+    startedAt: sourceTime
+  })).max(39)
+});
+var phaseShiftObservationSchema = z7.discriminatedUnion("version", [
+  phaseShiftObservationV1Schema,
+  phaseShiftObservationV2Schema
+]);
+
+// packages/time/dist/temporal.js
+import { Temporal as Polyfill } from "@js-temporal/polyfill";
+var engineTemporal = Reflect.get(globalThis, "Temporal");
+
+// packages/plugin-protocol/dist/transcript-review.js
+var RUN_INPUT_CUSTOM_TYPE = "session_run_input";
+var ANSI_RE = new RegExp([
+  "\\u001b\\[[0-?]*[ -/]*[@-~]",
+  "\\u001b\\][^\\u0007\\u001b]*(?:\\u0007|\\u001b\\\\)",
+  "\\u001b[@-Z\\\\-_]",
+  "\\[[0-9;]*m"
+].join("|"), "g");
+
+// packages/agent-runtime-protocol/dist/model-change-reason.js
+var MODEL_CHANGE_REASON_CUSTOM_TYPE = "model_change_reason";
+
+// packages/agent-runtime-protocol/dist/run-offline-stop.js
+import { z as z8 } from "zod";
+var RUN_OFFLINE_STOP_CUSTOM_TYPE = "run_offline_stop";
+var runOfflineStopSchema = z8.strictObject({
+  failureRef: failureRefSchema
+});
+
+// packages/agent-runtime-protocol/dist/routed-send.js
+function standsInForHumanSend(details) {
+  return typeof details === "object" && details !== null && details.standsInForHumanSend === true;
+}
+
+// packages/agent-runtime-protocol/dist/transcript-type-table.js
+function recordOf(value) {
+  return typeof value === "object" && value !== null ? value : void 0;
+}
+function stringField2(details, key) {
+  const value = recordOf(details)?.[key];
+  return typeof value === "string" ? value : void 0;
+}
+var DAEMON_SERVICE_AUDIENCE = {
+  wake: "model",
+  subagent_brief: "person",
+  subagent_wake: "model",
+  automation: "model",
+  followup_lane: "model",
+  continuation: "person"
+};
+function daemonServiceOf(details) {
+  const service = stringField2(details, "service");
+  return service !== void 0 && Object.hasOwn(DAEMON_SERVICE_AUDIENCE, service) ? service : void 0;
+}
+function unansweredPermissionKind(details) {
+  if (stringField2(details, "noticeKind") !== "permission_ask_unanswered")
+    return void 0;
+  const kind = stringField2(details, "kind");
+  return kind === "expired" || kind === "undisplayed" ? kind : void 0;
+}
+function answersToolCall(details) {
+  const toolCallId = stringField2(details, "toolCallId");
+  return toolCallId === void 0 ? void 0 : { toolCallId };
+}
+function answersDraftCard(details) {
+  const toolCallId = stringField2(details, "reviewToolCallId");
+  if (toolCallId === void 0)
+    return void 0;
+  const elementId = stringField2(details, "elementId");
+  return elementId === void 0 ? { toolCallId } : { toolCallId, elementId };
+}
+function herdPlacement(typeKey) {
+  const row = DEFAULT_CUSTOM_MESSAGE_PLACEMENTS.get(typeKey);
+  if (row === void 0)
+    throw new Error(`@herd/transcript has no placement for ${typeKey}`);
+  return row.placement;
+}
+var MESSAGE_DRAFT_SENT_TYPE = "message_draft_sent";
+var INTERRUPTED_RUN_RESUME_NOTE_CUSTOM_TYPE = "interrupted_run_resume_note";
+var ROWS = [
+  // The six companions of a person's send, delivered in the same batch as its text: context and
+  // attachments before it, dynamic context after. The bubble draws the three the person made
+  // (attachments as its footer, an invoked command as its pill, a paste inline where it was
+  // typed); the other three are context computed for the model. A card answer is not one (a
+  // parts-only send is the input itself), nor is a shell command the person ran (a record of
+  // its own, never tied to a text send).
+  {
+    typeKey: ATTACHMENTS_CUSTOM_TYPE,
+    kinds: ["context"],
+    placement: herdPlacement(ATTACHMENTS_CUSTOM_TYPE),
+    audience: "person"
+  },
+  {
+    typeKey: USER_INVOKED_CUSTOM_TYPE,
+    kinds: ["context"],
+    placement: herdPlacement(USER_INVOKED_CUSTOM_TYPE),
+    audience: "person"
+  },
+  {
+    typeKey: USER_PASTED_CONTENT_CUSTOM_TYPE,
+    kinds: ["context"],
+    placement: herdPlacement(USER_PASTED_CONTENT_CUSTOM_TYPE),
+    audience: "person"
+  },
+  // The shell's ambient pane projection (north-star §5).
+  {
+    typeKey: TAB_CONTEXT_CUSTOM_TYPE,
+    kinds: ["context"],
+    placement: "companion-of-send",
+    audience: "model"
+  },
+  // The pills the person picked, serialized for the agent's resolution; the bubble already shows
+  // them as the marker text they typed.
+  {
+    typeKey: COMPOSER_REFERENCES_CUSTOM_TYPE,
+    kinds: ["context"],
+    placement: "companion-of-send",
+    audience: "model"
+  },
+  // Retrieved memory and skill context, not work done on the person's behalf.
+  {
+    typeKey: DYNAMIC_CONTEXT_CUSTOM_TYPE,
+    kinds: ["context"],
+    placement: herdPlacement(DYNAMIC_CONTEXT_CUSTOM_TYPE),
+    audience: "model"
+  },
+  // A card answer is the person's, and the card shows it: a spent MessageDraft reads Approved,
+  // an answered Card collapses to the pressed label (ruling 2026-09-03). A row of its own repeated
+  // it as the raw wire payload. Known gap: only MessageDraft rehydrates what was submitted, so a
+  // typed Field value or an answer to a Button outside a Card survives a reload only in raw mode.
+  {
+    typeKey: UI_ACTION_CUSTOM_TYPE,
+    kinds: ["said"],
+    placement: herdPlacement(UI_ACTION_CUSTOM_TYPE),
+    audience: "person",
+    answers: answersToolCall
+  },
+  {
+    typeKey: MESSAGE_DRAFT_SENT_TYPE,
+    kinds: ["context"],
+    placement: "standalone",
+    audience: "model",
+    answers: answersDraftCard
+  },
+  {
+    typeKey: "plugin_card_submitted",
+    kinds: ["context"],
+    placement: "standalone",
+    audience: "model"
+  },
+  // Tells the agent a send's outcome is unknown so it does not send again. Its text is an
+  // instruction to the model. Known gap (#13684): the card states the outcome to the person only
+  // in the renderer that pressed Send. It does not read this record, so after a reload or a daemon
+  // restart it shows idle until a second press, which the daemon refuses as unconfirmed.
+  {
+    typeKey: "message_draft_send_unknown",
+    kinds: ["context"],
+    placement: "standalone",
+    audience: "model",
+    answers: answersDraftCard
+  },
+  // The daemon's agent-only note of a person's decision on an expired approval.
+  {
+    typeKey: "approval_decision",
+    kinds: ["context"],
+    placement: "standalone",
+    audience: "model"
+  },
+  {
+    typeKey: USER_SHELL_COMMAND_CUSTOM_TYPE,
+    kinds: ["work"],
+    placement: "standalone",
+    audience: "person"
+  },
+  {
+    typeKey: COLLABORATION_MESSAGE_CUSTOM_TYPE,
+    kinds: ["said"],
+    placement: "standalone",
+    audience: "person"
+  },
+  // A settled result joins the agent turn that awaits it; one that does not read as settled
+  // detached work stands where it landed. A spawn can keep its result out of the person's
+  // transcript; that one is outside it.
+  {
+    typeKey: SUBAGENT_RESULT_CUSTOM_TYPE,
+    kinds: ["said"],
+    placement: herdPlacement(SUBAGENT_RESULT_CUSTOM_TYPE),
+    audience: "person"
+  },
+  {
+    typeKey: BACKGROUND_TASK_RESULT_CUSTOM_TYPE,
+    kinds: ["work"],
+    placement: herdPlacement(BACKGROUND_TASK_RESULT_CUSTOM_TYPE),
+    audience: "person"
+  },
+  // Maintenance the run already performed, not an input the agent resumes on: post-run
+  // compaction routinely lands after the final answer while the run is still open, and
+  // counting it kept that answered turn reading as still working.
+  {
+    typeKey: COMPACTION_MARKER_CUSTOM_TYPE,
+    kinds: ["context"],
+    placement: herdPlacement(COMPACTION_MARKER_CUSTOM_TYPE),
+    audience: "person"
+  },
+  // Fails closed: a service this release cannot read is the daemon's plumbing.
+  {
+    typeKey: DAEMON_SERVICE_TURN_CUSTOM_TYPE,
+    kinds: ["said", "context"],
+    // A wake delivery joins the agent turn it wakes; every other service stands where it landed.
+    placement: herdPlacement(DAEMON_SERVICE_TURN_CUSTOM_TYPE),
+    audience: (details) => {
+      const service = daemonServiceOf(details);
+      return service === void 0 ? void 0 : DAEMON_SERVICE_AUDIENCE[service];
+    },
+    onUndecodable: "hide"
+  },
+  // A notice whose kind is new to this release still reads as a generic notice. A missed-approval
+  // notice of a kind this release does not know cannot say what was missed, so it hides.
+  {
+    typeKey: RUNTIME_NOTICE_CUSTOM_TYPE,
+    kinds: ["notice"],
+    placement: "standalone",
+    audience: (details) => stringField2(details, "noticeKind") === "permission_ask_unanswered" && unansweredPermissionKind(details) === void 0 ? void 0 : "person",
+    onUndecodable: "hide"
+  },
+  // Model-facing statements. Each was once visible for no decided reason, because this
+  // classification allows by default.
+  //
+  // Who the person is connected as and what waits on a connect; Plugins and Connections show it
+  // better, and the body instructs the agent.
+  {
+    typeKey: AVAILABILITY_FACTS_CUSTOM_TYPE,
+    kinds: ["context"],
+    placement: "standalone",
+    audience: "model"
+  },
+  // The kernel telling the model a section of its own frozen instructions moved (#2996).
+  {
+    typeKey: SYSTEM_PROMPT_DELTA_CUSTOM_TYPE,
+    kinds: ["context"],
+    placement: "standalone",
+    audience: "model"
+  },
+  // The statement into a forked headless session that no person is present.
+  {
+    typeKey: HEADLESS_OPERATION_CUSTOM_TYPE,
+    kinds: ["context"],
+    placement: "standalone",
+    audience: "model"
+  },
+  // The note sent with a resumed run's first request: check before repeating an action.
+  {
+    typeKey: INTERRUPTED_RUN_RESUME_NOTE_CUSTOM_TYPE,
+    kinds: ["context"],
+    placement: "standalone",
+    audience: "model"
+  },
+  // A compaction reminder riding the last result of a fan-out.
+  {
+    typeKey: "phase_shift_nudge",
+    kinds: ["context"],
+    placement: "standalone",
+    audience: "model"
+  },
+  // Retired 2026-10-19 (the primer now rides the first call's result); older transcripts hold it.
+  {
+    typeKey: "auto_primer",
+    kinds: ["context"],
+    placement: "standalone",
+    audience: "model"
+  },
+  // The kernel's notes to the model. The repair joins the agent turn it asks to finish; the other
+  // two stay out of the transcript.
+  {
+    typeKey: MID_TURN_COMPACTION_OUTCOME_CUSTOM_TYPE,
+    kinds: ["context"],
+    placement: herdPlacement(MID_TURN_COMPACTION_OUTCOME_CUSTOM_TYPE),
+    audience: "model"
+  },
+  {
+    typeKey: FINAL_OUTPUT_REPAIR_CUSTOM_TYPE,
+    kinds: ["context"],
+    placement: herdPlacement(FINAL_OUTPUT_REPAIR_CUSTOM_TYPE),
+    audience: "model"
+  },
+  {
+    typeKey: RUN_CONTINUATION_CARRIER_CUSTOM_TYPE,
+    kinds: ["context"],
+    placement: herdPlacement(RUN_CONTINUATION_CARRIER_CUSTOM_TYPE),
+    audience: "model"
+  },
+  // What the person sees when the policy changes their model, and a send a helper answered in the
+  // session model's place (both drawn by the smart-model-selection plugin).
+  {
+    typeKey: "model_selection_change",
+    kinds: ["notice"],
+    placement: "standalone",
+    audience: "person"
+  },
+  {
+    typeKey: "model_selection_handoff",
+    kinds: ["said"],
+    placement: "opens-turn",
+    audience: "person"
+  },
+  // Synthesized while reading, never written: a failed reply the renderer redraws as a
+  // provider-switch notice, and activity the reducer could not classify.
+  {
+    typeKey: "kay.provider_fallback",
+    kinds: ["notice"],
+    placement: "standalone",
+    audience: "person"
+  },
+  {
+    typeKey: "herd.unknown_activity",
+    kinds: ["unrecognized"],
+    placement: "standalone",
+    audience: "person"
+  }
+];
+function keyedRows(rows) {
+  const table = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (table.has(row.typeKey))
+      throw new Error(`two type rows for ${row.typeKey}`);
+    table.set(row.typeKey, row);
+  }
+  return table;
+}
+var UNLISTED_TRANSCRIPT_TYPE_ROW = {
+  typeKey: OTHER_CUSTOM_TYPES,
+  kinds: ["unrecognized"],
+  placement: (details, display) => standsInForHumanSend(details) ? "opens-turn" : customMessagePlacement(void 0, details, display),
+  audience: "person"
+};
+var TRANSCRIPT_TYPE_TABLE = keyedRows(ROWS);
+var TRANSCRIPT_PLACEMENTS = new Map([
+  ...TRANSCRIPT_TYPE_TABLE,
+  [OTHER_CUSTOM_TYPES, UNLISTED_TRANSCRIPT_TYPE_ROW]
+]);
+var ENTRY_ROWS = [
+  // The daemon's bookkeeping. These were 20.3% of every attach snapshot and 26% of every tail
+  // preview on 60 real transcripts (2026-09-01, apps/kay/bench/daemon-memory/projection-size.mjs);
+  // a single resolved prompt is ~160 KB and a session writes one per daemon restart. Most are
+  // spelled here because their constants live in @bonsai/agent-runtime, which this package cannot
+  // import; the daemon's census test pins each constant to its row.
+  ...[
+    RUN_FAILURE_CUSTOM_TYPE,
+    PHASE_SHIFT_CUSTOM_TYPE,
+    RUN_TERMINAL_CUSTOM_TYPE2,
+    RUN_STARTED_CUSTOM_TYPE,
+    RUN_INPUT_CUSTOM_TYPE,
+    "cwd_transition",
+    "project_transition",
+    "user_title",
+    "agent_identity",
+    "session_provenance",
+    "processing_speed",
+    "definition_permission_authority",
+    "registered_definition_pointer",
+    "inherited_definition_rules_pointer",
+    "final_output_contract",
+    "headless_session",
+    "session_cleared",
+    "composition_snapshot",
+    "resolved_prompt",
+    "model_selection",
+    "owed_reply",
+    // Replaced by owed_reply entries (session index migration 3); older logs still hold it.
+    "subagent_task_lifecycle_event",
+    // Retired 2026-09-10 with the daemon workspace roster; no install wrote one, but a log that did
+    // must still keep it off the surface.
+    "workspace_ref",
+    // Converted pi 0.99.1 config records: data migration 4 keeps a format-3 transcript's session
+    // name, model, thinking level and tool records as entries; their values live in the session's
+    // own documents.
+    "session_info",
+    "model_change",
+    "thinking_level_change",
+    "active_tools_change"
+  ].map((typeKey) => ({ typeKey, audience: "host-only" })),
+  // Daemon-written, surface-read: the steward's recap trailer, the provider-switch notice
+  // (provider-fallback-transcript.ts, #6370) and the recovered-run notice.
+  { typeKey: "session_steward", audience: "person" },
+  { typeKey: MODEL_CHANGE_REASON_CUSTOM_TYPE, audience: "person" },
+  { typeKey: RUN_RECOVERY_CUSTOM_TYPE, audience: "person" },
+  { typeKey: RUN_OFFLINE_STOP_CUSTOM_TYPE, audience: "person" }
+];
+var CUSTOM_ENTRY_TYPE_TABLE = keyedRows(ENTRY_ROWS);
+
+// packages/agent-runtime-protocol/dist/failure-echo.js
+function stripErrorLabel(text) {
+  return text.replace(/^\s*(?:\S+\s+)?error:\s*/i, "").trim();
+}
+function echoesFailure(text, failure) {
+  const candidate = stripErrorLabel(text);
+  if (candidate === "")
+    return false;
+  if (candidate === failure)
+    return true;
+  if (looksLikeHtml(candidate) && readableFailureText(candidate) === failure) {
+    return true;
+  }
+  return failure.endsWith("\u2026") && candidate.startsWith(failure.slice(0, -1));
+}
+function withoutFailureEcho(item) {
+  const failure = stripErrorLabel(item.failureText ?? "");
+  if (failure === "")
+    return item;
+  const parts = item.parts.filter((part) => part.type !== "text" || !echoesFailure(part.text, failure));
+  return parts.length === item.parts.length ? item : { ...item, parts };
+}
+function visibleTextWithoutFailureEcho(item) {
+  if (item.parts.length === 0) {
+    const text = item.text ?? "";
+    const failure = stripErrorLabel(item.failureText ?? "");
+    return failure !== "" && echoesFailure(text, failure) ? "" : text;
+  }
+  const texts = [];
+  for (const part of withoutFailureEcho(item).parts) {
+    if (part.type === "text")
+      texts.push(part.text);
+  }
+  return texts.join("\n");
+}
+
+// packages/agent-runtime-protocol/dist/answer-stretch.js
+function isReply2(block) {
+  return block.kind === "final_answer" || block.kind === "provisional_response";
+}
+function isBackgroundInput(block) {
+  if (block.kind !== "custom_message")
+    return false;
+  const { message } = block;
+  if (isEmbeddedAgentResultMessage(message) || isDaemonWakeMessage(message))
+    return true;
+  if (message.customType !== DAEMON_SERVICE_TURN_CUSTOM_TYPE)
+    return false;
+  const service = daemonServiceOf(message.details);
+  return service === "automation" || service === "followup_lane";
+}
+function isBareFailureReply(block) {
+  return block.status === "failed" && visibleTextWithoutFailureEcho(block.source).trim() === "";
+}
+function isStretchAnswer(block) {
+  return isReply2(block) && !isBareFailureReply(block) && block.text.trim() !== "";
+}
+function answerStretchStarts(blocks) {
+  const starts = /* @__PURE__ */ new Set();
+  let answered = false;
+  let pendingInput;
+  for (const block of blocks) {
+    if (block.kind === "steer_message") {
+      starts.add(block.id);
+      answered = false;
+      pendingInput = void 0;
+    } else if (answered && pendingInput === void 0 && isBackgroundInput(block)) {
+      pendingInput = block.id;
+    } else if (isStretchAnswer(block)) {
+      if (pendingInput !== void 0)
+        starts.add(pendingInput);
+      pendingInput = void 0;
+      answered = true;
+    }
+  }
+  return starts;
+}
+function stretchOpeningResults(blocks, start) {
+  const results = [];
+  for (const block of blocks.slice(start)) {
+    if (block.kind !== "custom_message")
+      break;
+    if (isEmbeddedAgentResultMessage(block.message))
+      results.push(block);
+  }
+  return results;
+}
 export {
+  TRANSCRIPT_TYPE_TABLE,
+  answerStretchStarts,
   customMessagePlacement,
   eventsForEntry,
   projectCanonicalTranscript,
   reconstructInteractiveState,
-  runBoundaryReplayEvent
+  runBoundaryReplayEvent,
+  stretchOpeningResults
 };